[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Getfem-commits] (no subject)
|
From: |
Konstantinos Poulios |
|
Subject: |
[Getfem-commits] (no subject) |
|
Date: |
Thu, 20 Dec 2018 03:46:29 -0500 (EST) |
branch: integration-point-variables
commit 14147e6bcbec3a69e92f04f5f521eefc65e873a2
Author: Konstantinos Poulios <address@hidden>
Date: Thu Dec 20 01:46:38 2018 +0100
Code cleanup
---
interface/src/gf_asm.cc | 4 +-
src/getfem/getfem_generic_assembly.h | 10 +-
src/getfem_generic_assembly_compile_and_exec.cc | 97 ++--
src/getfem_generic_assembly_semantic.cc | 7 +-
src/getfem_generic_assembly_tree.cc | 663 ++++++++++++------------
src/getfem_generic_assembly_workspace.cc | 7 +-
src/getfem_mesh.cc | 2 +-
src/getfem_models.cc | 54 +-
8 files changed, 420 insertions(+), 424 deletions(-)
diff --git a/interface/src/gf_asm.cc b/interface/src/gf_asm.cc
index 42416af..2bf431a 100644
--- a/interface/src/gf_asm.cc
+++ b/interface/src/gf_asm.cc
@@ -799,9 +799,9 @@ void gf_asm(getfemint::mexargs_in& m_in,
getfemint::mexargs_out& m_out) {
functions are only available for variables, not for constants.
`select_output` is an optional parameter which allows to reduce the
- output vecotr (for `order` equal to 1) or the matrix (for `order`
+ output vector (for `order` equal to 1) or the matrix (for `order`
equal to 2) to the degrees of freedom of the specified variables.
- One variable has to be specified for a vector ouptut and two for a
+ One variable has to be specified for a vector output and two for a
matrix output.
Note that if several variables are given, the assembly of the
diff --git a/src/getfem/getfem_generic_assembly.h
b/src/getfem/getfem_generic_assembly.h
index 265ba11..9468406 100644
--- a/src/getfem/getfem_generic_assembly.h
+++ b/src/getfem/getfem_generic_assembly.h
@@ -287,16 +287,18 @@ namespace getfem {
}
var_description(bool is_var, bool is_fem,
- const mesh_fem *mmf, gmm::sub_interval I_,
+ const mesh_fem *mf_, gmm::sub_interval I_,
const model_real_plain_vector *v, const im_data *imd_,
size_type Q)
- : is_variable(is_var), is_fem_dofs(is_fem), mf(mmf), I(I_), V(v),
- imd(imd_), qdims(1) {
+ : is_variable(is_var), is_fem_dofs(is_fem), mf(mf_), I(I_), V(v),
+ imd(imd_), qdims(1)
+ {
GMM_ASSERT1(Q > 0, "Bad dimension");
qdims[0] = Q;
}
var_description() : is_variable(false), is_fem_dofs(false),
- mf(0), V(0), imd(0), qdims(1) { qdims[0] = 1; }
+ mf(0), V(0), imd(0), qdims(1)
+ { qdims[0] = 1; }
};
public:
diff --git a/src/getfem_generic_assembly_compile_and_exec.cc
b/src/getfem_generic_assembly_compile_and_exec.cc
index baaa936..243d409 100644
--- a/src/getfem_generic_assembly_compile_and_exec.cc
+++ b/src/getfem_generic_assembly_compile_and_exec.cc
@@ -220,6 +220,7 @@ namespace getfem {
size_type s1 = pf1->nb_dof(cv_1) * Qmult1;
size_type Qmult2 = qdim2 / pf2->target_dim();
size_type s2 = pf2->nb_dof(cv_2) * Qmult2;
+ GMM_ASSERT1(s1 > 0 && s2 >0, "Element without degrees of freedom");
if (t.sizes()[0] != s1 || t.sizes()[1] != s2) {
bgeot::multi_index mi = t.sizes();
mi[0] = s1; mi[1] = s2;
@@ -3378,15 +3379,16 @@ namespace getfem {
// Performs Aij Bkl -> Cijkl, partially unrolled version
template<int S1> struct ga_instruction_simple_tmult_unrolled
- : public ga_instruction {
+ : public ga_instruction {
base_tensor &t, &tc1, &tc2;
virtual int exec() {
size_type s2 = tc2.size();
+ GA_DEBUG_ASSERT(tc1.size() == S1,
+ "Wrong sizes " << tc1.size() << " != " << S1);
GA_DEBUG_INFO("Instruction: simple tensor product, unrolled with "
- << tc1.size() << " operations");
- GA_DEBUG_ASSERT(t.size() == tc1.size() * s2, "Wrong sizes");
- GA_DEBUG_ASSERT(tc1.size() == S1, "Wrong sizes");
-
+ << S1 << " operations");
+ GA_DEBUG_ASSERT(t.size() == S1 * s2,
+ "Wrong sizes " << t.size() << " != " << S1 << "*" << s2);
base_tensor::iterator it = t.begin(), it2 = tc2.begin();
for (size_type ii = 0; ii < s2; ++ii, ++it2) {
base_tensor::iterator it1 = tc1.begin();
@@ -3987,7 +3989,7 @@ namespace getfem {
struct ga_instruction_scalar_assembly : public ga_instruction {
- base_tensor &t;
+ const base_tensor &t;
scalar_type &E, &coeff;
virtual int exec() {
GA_DEBUG_INFO("Instruction: scalar term assembly");
@@ -4000,7 +4002,7 @@ namespace getfem {
};
struct ga_instruction_fem_vector_assembly : public ga_instruction {
- base_tensor &t;
+ const base_tensor &t;
base_vector &Vr, &Vn;
const fem_interpolation_context &ctx;
const gmm::sub_interval &Ir, &In;
@@ -4016,7 +4018,9 @@ namespace getfem {
if (empty_weight) elem.resize(0);
elem.resize(t.size());
if (!empty_weight) {
- auto itt = t.begin(); auto it = elem.begin(), ite = elem.end();
+ auto itt = t.begin();
+ auto it = elem.begin();
+ const auto ite = elem.end();
size_type nd = ((t.size()) >> 2);
for (size_type i = 0; i < nd; ++i) {
*it++ = (*itt++) * coeff; *it++ = (*itt++) * coeff;
@@ -4025,7 +4029,9 @@ namespace getfem {
for (; it != ite;) *it++ = (*itt++) * coeff;
}
} else if (!empty_weight) {
- auto itt = t.begin(); auto it = elem.begin(), ite = elem.end();
+ auto itt = t.begin();
+ auto it = elem.begin();
+ const auto ite = elem.end();
size_type nd = ((t.size()) >> 2);
for (size_type i = 0; i < nd; ++i) {
*it++ += (*itt++) * coeff; *it++ += (*itt++) * coeff;
@@ -4058,7 +4064,7 @@ namespace getfem {
return 0;
}
ga_instruction_fem_vector_assembly
- (base_tensor &t_, base_vector &Vr_, base_vector &Vn_,
+ (const base_tensor &t_, base_vector &Vr_, base_vector &Vn_,
const fem_interpolation_context &ctx_,
const gmm::sub_interval &Ir_, const gmm::sub_interval &In_,
const mesh_fem *mfn_, const mesh_fem **mfg_,
@@ -4074,7 +4080,7 @@ namespace getfem {
base_vector &V;
const gmm::sub_interval &I;
scalar_type &coeff;
- virtual int exec() {
+ virtual int exec() {
GA_DEBUG_INFO("Instruction: vector term assembly for "
"fixed size variable");
gmm::add(gmm::scaled(t.as_vector(), coeff), gmm::sub_vector(V, I));
@@ -4268,7 +4274,7 @@ namespace getfem {
} else {
for (auto itt = ct1.begin(); itt != ct1.end(); ++itt)
for (size_type q = 0; q < qmult1; ++q)
- *itd++ += *itt + q;
+ *itd++ += *itt + q;
}
} else
for (size_type i=0; i < s1; ++i) dofs1[i] += i;
@@ -4712,9 +4718,9 @@ namespace getfem {
} else {
if (gis.var_intervals.find(varname) == gis.var_intervals.end()) {
const mesh_fem *mf = workspace.associated_mf(varname);
- size_type nd = mf ? mf->nb_basic_dof() :
- gmm::vect_size(workspace.value(varname));
- gis.var_intervals[varname]=gmm::sub_interval(gis.nb_dof, nd);
+ size_type nd = mf ? mf->nb_basic_dof()
+ : gmm::vect_size(workspace.value(varname));
+ gis.var_intervals[varname] = gmm::sub_interval(gis.nb_dof, nd);
gis.nb_dof += nd;
}
gis.max_dof = std::max(gis.max_dof,
@@ -6696,7 +6702,7 @@ namespace getfem {
if ((version == td.interpolation) &&
((version == 0 && td.order == order) || // Assembly
((version > 0 && (td.order == size_type(-1) || // Assignment
- td.order == size_type(-2) - order))))) {
+ td.order == size_type(-2) - order))))) {
ga_tree *added_tree = 0;
if (td.interpolation) {
gis.interpolation_trees.push_back(*(td.ptree));
@@ -6756,14 +6762,14 @@ namespace getfem {
"Invalid vector or tensor quantity. An order 1 "
"weak form has to be a scalar quantity");
const mesh_fem *mf=workspace.associated_mf(root->name_test1);
- const mesh_fem **mfg = 0;
add_interval_to_gis(workspace, root->name_test1, gis);
if (mf) {
- const std::string &intn1 = root->interpolate_name_test1;
+ const mesh_fem **mfg = 0;
const gmm::sub_interval *Ir = 0, *In = 0;
+ const std::string &intn1 = root->interpolate_name_test1;
bool secondary = intn1.size() &&
- workspace.secondary_domain_exists(intn1);
+ workspace.secondary_domain_exists(intn1);
if (intn1.size() && !secondary &&
workspace.variable_group_exists(root->name_test1)) {
ga_instruction_set::variable_group_info &vgi =
@@ -6778,12 +6784,13 @@ namespace getfem {
In = &(workspace.interval_of_variable(root->name_test1));
}
fem_interpolation_context &ctx
- = intn1.size() ?
- (secondary ? rmi.secondary_domain_infos.ctx
- : rmi.interpolate_infos[intn1].ctx) : gis.ctx;
- bool interpolate
- = (!intn1.empty() && intn1.compare("neighbour_elt")!=0 &&
- !secondary);
+ = intn1.size()
+ ? (secondary ? rmi.secondary_domain_infos.ctx
+ : rmi.interpolate_infos[intn1].ctx)
+ : gis.ctx;
+ bool interpolate = !(intn1.empty() ||
+ intn1 == "neighbour_elt" ||
+ secondary);
pgai = std::make_shared<ga_instruction_fem_vector_assembly>
(root->tensor(), workspace.unreduced_vector(),
workspace.assembled_vector(), ctx, *Ir, *In, mf, mfg,
@@ -6810,19 +6817,19 @@ namespace getfem {
workspace.secondary_domain_exists(intn1);
bool secondary2 = intn2.size() &&
workspace.secondary_domain_exists(intn2);
- fem_interpolation_context &ctx1
- = intn1.size() ?
- (secondary1 ? rmi.secondary_domain_infos.ctx
- : rmi.interpolate_infos[intn1].ctx) : gis.ctx;
- fem_interpolation_context &ctx2
- = intn2.size() ?
- (secondary2 ? rmi.secondary_domain_infos.ctx
- : rmi.interpolate_infos[intn2].ctx) : gis.ctx;
- bool interpolate
- = (!intn1.empty() && intn1.compare("neighbour_elt")!=0 &&
- !secondary1) ||
- (!intn2.empty() && intn2.compare("neighbour_elt")!=0 &&
- !secondary2);
+ fem_interpolation_context
+ &ctx1 = intn1.size()
+ ? (secondary1 ? rmi.secondary_domain_infos.ctx
+ : rmi.interpolate_infos[intn1].ctx)
+ : gis.ctx,
+ &ctx2 = intn2.size()
+ ? (secondary2 ? rmi.secondary_domain_infos.ctx
+ : rmi.interpolate_infos[intn2].ctx)
+ : gis.ctx;
+ bool interpolate = !(intn1.empty() || intn1 ==
"neighbour_elt"
+ || secondary1) ||
+ !(intn2.empty() || intn2 ==
"neighbour_elt"
+ || secondary2);
add_interval_to_gis(workspace, root->name_test1, gis);
add_interval_to_gis(workspace, root->name_test2, gis);
@@ -6862,23 +6869,23 @@ namespace getfem {
In2 = &(workspace.interval_of_variable(root->name_test2));
}
- if (!interpolate && mfg1 == 0 && mfg2 == 0 && mf1 && mf2
- && mf1->get_qdim() == 1 && mf2->get_qdim() == 1
- && !(mf1->is_reduced()) && !(mf2->is_reduced())) {
+ bool simple = !interpolate &&
+ mfg1 == 0 && mfg2 == 0 && mf1 && mf2 &&
+ !(mf1->is_reduced()) && !(mf2->is_reduced());
+ if (simple && mf1->get_qdim() == 1 && mf2->get_qdim() == 1) {
pgai = std::make_shared
<ga_instruction_matrix_assembly_standard_scalar<>>
(root->tensor(), workspace.assembled_matrix(), ctx1,
ctx2,
*In1, *In2, mf1, mf2,
gis.coeff, *alpha1, *alpha2, gis.nbpt, gis.ipt);
- } else if (!interpolate && mfg1 == 0 && mfg2==0 && mf1 && mf2
- && !(mf1->is_reduced()) && !(mf2->is_reduced())) {
- if (root->sparsity() == 10 && root->t.qdim()==2)
+ } else if (simple) {
+ if (root->sparsity() == 10 && root->t.qdim() == 2)
pgai = std::make_shared
<ga_instruction_matrix_assembly_standard_vector_opt10_2>
(root->tensor(),
workspace.assembled_matrix(),ctx1,ctx2,
*In1, *In2, mf1, mf2,
gis.coeff, *alpha1, *alpha2, gis.nbpt, gis.ipt);
- else if (root->sparsity() == 10 && root->t.qdim()==3)
+ else if (root->sparsity() == 10 && root->t.qdim() == 3)
pgai = std::make_shared
<ga_instruction_matrix_assembly_standard_vector_opt10_3>
(root->tensor(),
workspace.assembled_matrix(),ctx1,ctx2,
diff --git a/src/getfem_generic_assembly_semantic.cc
b/src/getfem_generic_assembly_semantic.cc
index 956f801..baa422f 100644
--- a/src/getfem_generic_assembly_semantic.cc
+++ b/src/getfem_generic_assembly_semantic.cc
@@ -1764,9 +1764,10 @@ namespace getfem {
if (n == 1) {
if (test) {
pnode->init_vector_tensor(1);
- pnode->tensor()[0]=scalar_type(1);
+ pnode->tensor()[0] = scalar_type(1);
}
- else pnode->init_scalar_tensor(workspace.value(name)[0]);
+ else
+ pnode->init_scalar_tensor(workspace.value(name)[0]);
} else {
if (test) {
pnode->init_matrix_tensor(n,n);
@@ -1794,7 +1795,7 @@ namespace getfem {
"Invalid null size of variable " << name);
if (mii.size() > 6)
ga_throw_error(pnode->expr, pnode->pos,
- "Tensor with too much dimensions. Limited to 6");
+ "Tensor with too many dimensions. Limited to 6");
switch (prefix_id) {
case 0: // value
diff --git a/src/getfem_generic_assembly_tree.cc
b/src/getfem_generic_assembly_tree.cc
index caffa4f..dce3a2e 100644
--- a/src/getfem_generic_assembly_tree.cc
+++ b/src/getfem_generic_assembly_tree.cc
@@ -186,7 +186,7 @@ namespace getfem {
//=========================================================================
void ga_throw_error_msg(pstring expr, size_type pos,
- const std::string &msg) {
+ const std::string &msg) {
int length_before = 70, length_after = 70;
if (expr && expr->size()) {
int first = std::max(0, int(pos)-length_before);
@@ -218,12 +218,11 @@ namespace getfem {
void ga_tree_node::mult_test(const pga_tree_node n0, const pga_tree_node n1)
{
size_type test0 = n0->test_function_type, test1 = n1->test_function_type;
- if (test0 && test1 && (test0 == test1 ||
- test0 >= 3 || test1 >= 3))
+ if (test0 && test1 && (test0 == test1 || test0 >= 3 || test1 >= 3))
ga_throw_error(expr, pos,
- "Incompatibility of test functions in product.");
+ "Incompatibility of test functions in product.");
GMM_ASSERT1(test0 != size_type(-1) && test1 != size_type(-1),
- "internal error");
+ "internal error");
test_function_type = test0 + test1;
@@ -288,7 +287,7 @@ namespace getfem {
}
void ga_tree::add_name(const char *name, size_type length, size_type pos,
- pstring expr) {
+ pstring expr) {
while (current_node && current_node->node_type != GA_NODE_OP)
current_node = current_node->parent;
if (current_node) {
@@ -304,23 +303,23 @@ namespace getfem {
void ga_tree::add_sub_tree(ga_tree &sub_tree) {
if (current_node &&
- (current_node->node_type == GA_NODE_PARAMS ||
- current_node->node_type == GA_NODE_INTERPOLATE_FILTER ||
- current_node->node_type == GA_NODE_C_MATRIX)) {
+ (current_node->node_type == GA_NODE_PARAMS ||
+ current_node->node_type == GA_NODE_INTERPOLATE_FILTER ||
+ current_node->node_type == GA_NODE_C_MATRIX)) {
GMM_ASSERT1(sub_tree.root, "Invalid tree operation");
current_node->adopt_child(sub_tree.root);
} else {
GMM_ASSERT1(sub_tree.root, "Invalid tree operation");
while (current_node && current_node->node_type != GA_NODE_OP)
- current_node = current_node->parent;
+ current_node = current_node->parent;
if (current_node) {
- current_node->adopt_child(sub_tree.root);
- current_node = sub_tree.root;
+ current_node->adopt_child(sub_tree.root);
+ current_node = sub_tree.root;
}
else {
- GMM_ASSERT1(root == nullptr, "Invalid tree operation");
- current_node = root = sub_tree.root;
- root->parent = nullptr;
+ GMM_ASSERT1(root == nullptr, "Invalid tree operation");
+ current_node = root = sub_tree.root;
+ root->parent = nullptr;
}
}
sub_tree.root = sub_tree.current_node = nullptr;
@@ -329,8 +328,8 @@ namespace getfem {
void ga_tree::add_params(size_type pos, pstring expr) {
GMM_ASSERT1(current_node, "internal error");
while (current_node && current_node->parent &&
- current_node->parent->node_type == GA_NODE_OP &&
- ga_operator_priorities[current_node->parent->op_type] >= 4)
+ current_node->parent->node_type == GA_NODE_OP &&
+ ga_operator_priorities[current_node->parent->op_type] >= 4)
current_node = current_node->parent;
pga_tree_node new_node = new ga_tree_node(GA_NODE_PARAMS, pos, expr);
new_node->parent = current_node->parent;
@@ -358,26 +357,26 @@ namespace getfem {
}
void ga_tree::add_op(GA_TOKEN_TYPE op_type, size_type pos,
- pstring expr) {
+ pstring expr) {
while (current_node && current_node->parent &&
- current_node->parent->node_type == GA_NODE_OP &&
- ga_operator_priorities[current_node->parent->op_type]
- >= ga_operator_priorities[op_type])
+ current_node->parent->node_type == GA_NODE_OP &&
+ ga_operator_priorities[current_node->parent->op_type]
+ >= ga_operator_priorities[op_type])
current_node = current_node->parent;
pga_tree_node new_node = new ga_tree_node(op_type, pos, expr);
if (current_node) {
if (op_type == GA_UNARY_MINUS
- || op_type == GA_SYM || op_type == GA_SKEW
- || op_type == GA_TRACE || op_type == GA_DEVIATOR
- || op_type == GA_PRINT) {
- current_node->adopt_child(new_node);
+ || op_type == GA_SYM || op_type == GA_SKEW
+ || op_type == GA_TRACE || op_type == GA_DEVIATOR
+ || op_type == GA_PRINT) {
+ current_node->adopt_child(new_node);
} else {
- new_node->parent = current_node->parent;
- if (current_node->parent)
- current_node->parent->replace_child(current_node, new_node);
- else
- root = new_node;
- new_node->adopt_child(current_node);
+ new_node->parent = current_node->parent;
+ if (current_node->parent)
+ current_node->parent->replace_child(current_node, new_node);
+ else
+ root = new_node;
+ new_node->adopt_child(current_node);
}
} else {
if (root) new_node->adopt_child(root);
@@ -390,7 +389,7 @@ namespace getfem {
void ga_tree::clear_node_rec(pga_tree_node pnode) {
if (pnode) {
for (pga_tree_node &child : pnode->children)
- clear_node_rec(child);
+ clear_node_rec(child);
delete pnode;
current_node = nullptr;
}
@@ -400,13 +399,13 @@ namespace getfem {
if (pnode) {
pga_tree_node parent = pnode->parent;
if (parent) { // keep all siblings of pnode
- size_type j = 0;
- for (pga_tree_node &sibling : parent->children)
- if (sibling != pnode)
- parent->children[j++] = sibling;
- parent->children.resize(j);
+ size_type j = 0;
+ for (pga_tree_node &sibling : parent->children)
+ if (sibling != pnode)
+ parent->children[j++] = sibling;
+ parent->children.resize(j);
} else
- root = nullptr;
+ root = nullptr;
}
clear_node_rec(pnode);
}
@@ -432,7 +431,7 @@ namespace getfem {
}
void ga_tree::copy_node(pga_tree_node pnode, pga_tree_node parent,
- pga_tree_node &child) {
+ pga_tree_node &child) {
GMM_ASSERT1(child == nullptr, "Internal error");
child = new ga_tree_node();
*child = *pnode;
@@ -444,7 +443,7 @@ namespace getfem {
}
void ga_tree::duplicate_with_operation(pga_tree_node pnode,
- GA_TOKEN_TYPE op_type) {
+ GA_TOKEN_TYPE op_type) {
pga_tree_node newop = new ga_tree_node(op_type, pnode->pos, pnode->expr);
newop->children.resize(2, nullptr);
newop->children[0] = pnode;
@@ -1091,65 +1090,65 @@ namespace getfem {
GMM_ASSERT1(pnode->nbc1 == pnode->tensor_order(), "Invalid C_MATRIX");
switch (pnode->tensor_order()) {
case 0:
- ga_print_node(pnode->children[0], str);
- break;
-
+ ga_print_node(pnode->children[0], str);
+ break;
+
case 1:
- str << "[";
- for (size_type i = 0; i < pnode->tensor_proper_size(0); ++i) {
- if (i != 0) str << ",";
- ga_print_node(pnode->children[i], str);
- }
- str << "]";
- break;
-
+ str << "[";
+ for (size_type i = 0; i < pnode->tensor_proper_size(0); ++i) {
+ if (i != 0) str << ",";
+ ga_print_node(pnode->children[i], str);
+ }
+ str << "]";
+ break;
+
case 2: case 3: case 4:
- {
- size_type ii(0);
- size_type n0 = pnode->tensor_proper_size(0);
- size_type n1 = pnode->tensor_proper_size(1);
- size_type n2 = ((pnode->tensor_order() > 2) ?
- pnode->tensor_proper_size(2) : 1);
- size_type n3 = ((pnode->tensor_order() > 3) ?
- pnode->tensor_proper_size(3) : 1);
- if (n3 > 1) str << "[";
- for (size_type l = 0; l < n3; ++l) {
- if (l != 0) str << ",";
- if (n2 > 1) str << "[";
- for (size_type k = 0; k < n2; ++k) {
- if (k != 0) str << ",";
- if (n1 > 1) str << "[";
- for (size_type j = 0; j < n1; ++j) {
- if (j != 0) str << ",";
- if (n0 > 1) str << "[";
- for (size_type i = 0; i < n0; ++i) {
- if (i != 0) str << ",";
- ga_print_node(pnode->children[ii++], str);
- }
- if (n0 > 1) str << "]";
- }
- if (n1 > 1) str << "]";
- }
- if (n2 > 1) str << "]";
- }
- if (n3 > 1) str << "]";
- }
- break;
-
+ {
+ size_type ii(0);
+ size_type n0 = pnode->tensor_proper_size(0);
+ size_type n1 = pnode->tensor_proper_size(1);
+ size_type n2 = ((pnode->tensor_order() > 2) ?
+ pnode->tensor_proper_size(2) : 1);
+ size_type n3 = ((pnode->tensor_order() > 3) ?
+ pnode->tensor_proper_size(3) : 1);
+ if (n3 > 1) str << "[";
+ for (size_type l = 0; l < n3; ++l) {
+ if (l != 0) str << ",";
+ if (n2 > 1) str << "[";
+ for (size_type k = 0; k < n2; ++k) {
+ if (k != 0) str << ",";
+ if (n1 > 1) str << "[";
+ for (size_type j = 0; j < n1; ++j) {
+ if (j != 0) str << ",";
+ if (n0 > 1) str << "[";
+ for (size_type i = 0; i < n0; ++i) {
+ if (i != 0) str << ",";
+ ga_print_node(pnode->children[ii++], str);
+ }
+ if (n0 > 1) str << "]";
+ }
+ if (n1 > 1) str << "]";
+ }
+ if (n2 > 1) str << "]";
+ }
+ if (n3 > 1) str << "]";
+ }
+ break;
+
case 5: case 6: case 7: case 8:
- str << "Reshape([";
- for (size_type i = 0; i < pnode->tensor_proper_size(); ++i) {
- if (i != 0) str << ";";
- ga_print_node(pnode->children[i], str);
- }
- str << "]";
- for (size_type i = 0; i < pnode->tensor_order(); ++i) {
- if (i != 0) str << ", ";
- str << pnode->tensor_proper_size(i);
- }
- str << ")";
- break;
-
+ str << "Reshape([";
+ for (size_type i = 0; i < pnode->tensor_proper_size(); ++i) {
+ if (i != 0) str << ";";
+ ga_print_node(pnode->children[i], str);
+ }
+ str << "]";
+ for (size_type i = 0; i < pnode->tensor_order(); ++i) {
+ if (i != 0) str << ", ";
+ str << pnode->tensor_proper_size(i);
+ }
+ str << ")";
+ break;
+
default: GMM_ASSERT1(false, "Invalid tensor dimension");
}
break;
@@ -1291,149 +1290,149 @@ namespace getfem {
pga_tree_node pchild = children[pnode->nbc1+1];
if (po || pt) {
- if (!(pchild->children.empty()) || pchild->node_type != GA_NODE_NAME)
- ga_throw_error(pchild->expr, pchild->pos, "Error in macro "
- "expansion. Only variable name are allowed for macro "
- "parameter preceded by Grad_ Hess_ Test_ or Test2_ "
- "prefixes.");
- switch(pnode->op_type) {
- case GA_NAME : pnode->node_type = GA_NODE_NAME; break;
- case GA_INTERPOLATE : pnode->node_type = GA_NODE_INTERPOLATE; break;
- case GA_ELEMENTARY : pnode->node_type = GA_NODE_ELEMENTARY; break;
- case GA_SECONDARY_DOMAIN :
+ if (!(pchild->children.empty()) || pchild->node_type != GA_NODE_NAME)
+ ga_throw_error(pchild->expr, pchild->pos, "Error in macro "
+ "expansion. Only variable name are allowed for macro "
+ "parameter preceded by Grad_ Hess_ Test_ or Test2_ "
+ "prefixes.");
+ switch(pnode->op_type) {
+ case GA_NAME : pnode->node_type = GA_NODE_NAME; break;
+ case GA_INTERPOLATE : pnode->node_type = GA_NODE_INTERPOLATE; break;
+ case GA_ELEMENTARY : pnode->node_type = GA_NODE_ELEMENTARY; break;
+ case GA_SECONDARY_DOMAIN :
pnode->node_type = GA_NODE_SECONDARY_DOMAIN; break;
- case GA_XFEM_PLUS : pnode->node_type = GA_NODE_XFEM_PLUS; break;
- case GA_XFEM_MINUS: pnode->node_type = GA_NODE_XFEM_MINUS; break;
- default:break;
- }
- pnode->name = pchild->name;
- if (pt == 1) pnode->name = "Test_" + pnode->name;
- if (pt == 2) pnode->name = "Test2_" + pnode->name;
- if (po == 1) pnode->name = "Grad_" + pnode->name;
- if (po == 2) pnode->name = "Hess_" + pnode->name;
- if (po == 3) pnode->name = "Div_" + pnode->name;
+ case GA_XFEM_PLUS : pnode->node_type = GA_NODE_XFEM_PLUS; break;
+ case GA_XFEM_MINUS: pnode->node_type = GA_NODE_XFEM_MINUS; break;
+ default:break;
+ }
+ pnode->name = pchild->name;
+ if (pt == 1) pnode->name = "Test_" + pnode->name;
+ if (pt == 2) pnode->name = "Test2_" + pnode->name;
+ if (po == 1) pnode->name = "Grad_" + pnode->name;
+ if (po == 2) pnode->name = "Hess_" + pnode->name;
+ if (po == 3) pnode->name = "Div_" + pnode->name;
} else {
- pga_tree_node pnode_old = pnode;
- pnode = nullptr;
- tree.copy_node(pchild, pnode_old->parent, pnode);
- if (pnode_old->parent)
- pnode_old->parent->replace_child(pnode_old, pnode);
- else
- tree.root = pnode;
- GMM_ASSERT1(pnode_old->children.empty(), "Internal error");
- delete pnode_old;
+ pga_tree_node pnode_old = pnode;
+ pnode = nullptr;
+ tree.copy_node(pchild, pnode_old->parent, pnode);
+ if (pnode_old->parent)
+ pnode_old->parent->replace_child(pnode_old, pnode);
+ else
+ tree.root = pnode;
+ GMM_ASSERT1(pnode_old->children.empty(), "Internal error");
+ delete pnode_old;
}
}
}
static void ga_expand_macro(ga_tree &tree, pga_tree_node pnode,
- const ga_macro_dictionnary ¯o_dict) {
+ const ga_macro_dictionnary ¯o_dict) {
if (!pnode) return;
if (pnode->node_type == GA_NODE_PARAMS) {
for (size_type i = 1; i < pnode->children.size(); ++i)
- ga_expand_macro(tree, pnode->children[i], macro_dict);
+ ga_expand_macro(tree, pnode->children[i], macro_dict);
if (pnode->children[0]->node_type != GA_NODE_NAME) {
- ga_expand_macro(tree, pnode->children[0], macro_dict);
+ ga_expand_macro(tree, pnode->children[0], macro_dict);
} else {
-
- if (macro_dict.macro_exists(pnode->children[0]->name)) {
-
- const ga_macro &gam = macro_dict.get_macro(pnode->children[0]->name);
-
- if (gam.nb_params()==0) { // Macro without parameters
- pga_tree_node pnode_old = pnode->children[0];
- pnode->children[0] = nullptr;
- tree.copy_node(gam.tree().root,
- pnode_old->parent,pnode->children[0]);
- GMM_ASSERT1(pnode_old->children.empty(), "Internal error");
- delete pnode_old;
-
- } else { // Macro with parameters
-
- if (gam.nb_params()+1 != pnode->children.size())
- ga_throw_error(pnode->expr, pnode->pos,
- "Bad number of parameters in the use of macro '"
- << gam.name() << "'. Expected " << gam.nb_params()
- << " found " << pnode->children.size()-1 << ".");
-
- pga_tree_node pnode_old = pnode;
- pnode = nullptr;
- tree.copy_node(gam.tree().root, pnode_old->parent, pnode);
- if (pnode_old->parent)
- pnode_old->parent->replace_child(pnode_old, pnode);
- else
- tree.root = pnode;
- ga_replace_macro_params(tree, pnode, pnode_old->children);
- }
- }
+
+ if (macro_dict.macro_exists(pnode->children[0]->name)) {
+
+ const ga_macro &gam = macro_dict.get_macro(pnode->children[0]->name);
+
+ if (gam.nb_params()==0) { // Macro without parameters
+ pga_tree_node pnode_old = pnode->children[0];
+ pnode->children[0] = nullptr;
+ tree.copy_node(gam.tree().root,
+ pnode_old->parent,pnode->children[0]);
+ GMM_ASSERT1(pnode_old->children.empty(), "Internal error");
+ delete pnode_old;
+
+ } else { // Macro with parameters
+
+ if (gam.nb_params()+1 != pnode->children.size())
+ ga_throw_error(pnode->expr, pnode->pos,
+ "Bad number of parameters in the use of macro '"
+ << gam.name() << "'. Expected " << gam.nb_params()
+ << " found " << pnode->children.size()-1 << ".");
+
+ pga_tree_node pnode_old = pnode;
+ pnode = nullptr;
+ tree.copy_node(gam.tree().root, pnode_old->parent, pnode);
+ if (pnode_old->parent)
+ pnode_old->parent->replace_child(pnode_old, pnode);
+ else
+ tree.root = pnode;
+ ga_replace_macro_params(tree, pnode, pnode_old->children);
+ }
+ }
}
} else if (pnode->node_type == GA_NODE_NAME &&
- macro_dict.macro_exists(pnode->name)) {
+ macro_dict.macro_exists(pnode->name)) {
// Macro without parameters
const ga_macro &gam = macro_dict.get_macro(pnode->name);
if (gam.nb_params() != 0)
- ga_throw_error(pnode->expr, pnode->pos,
- "Bad number of parameters in the use of macro '"
- << gam.name() << "'. Expected " << gam.nb_params()
- << " none found.");
+ ga_throw_error(pnode->expr, pnode->pos,
+ "Bad number of parameters in the use of macro '"
+ << gam.name() << "'. Expected " << gam.nb_params()
+ << " none found.");
pga_tree_node pnode_old = pnode;
pnode = nullptr;
tree.copy_node(gam.tree().root, pnode_old->parent, pnode);
if (pnode_old->parent)
- pnode_old->parent->replace_child(pnode_old, pnode);
+ pnode_old->parent->replace_child(pnode_old, pnode);
else
- tree.root = pnode;
+ tree.root = pnode;
GMM_ASSERT1(pnode_old->children.empty(), "Internal error");
delete pnode_old;
} else {
for (size_type i = 0; i < pnode->children.size(); ++i)
- ga_expand_macro(tree, pnode->children[i], macro_dict);
+ ga_expand_macro(tree, pnode->children[i], macro_dict);
}
}
static void ga_mark_macro_params_rec(const pga_tree_node pnode,
- const std::vector<std::string> ¶ms) {
+ const std::vector<std::string> ¶ms)
{
if (!pnode) return;
for (size_type i = 0; i < pnode->children.size(); ++i)
ga_mark_macro_params_rec(pnode->children[i], params);
if (pnode->node_type == GA_NODE_NAME ||
- pnode->node_type == GA_NODE_INTERPOLATE ||
- pnode->node_type == GA_NODE_ELEMENTARY ||
- pnode->node_type == GA_NODE_SECONDARY_DOMAIN ||
- pnode->node_type == GA_NODE_XFEM_PLUS ||
- pnode->node_type == GA_NODE_XFEM_MINUS) {
+ pnode->node_type == GA_NODE_INTERPOLATE ||
+ pnode->node_type == GA_NODE_ELEMENTARY ||
+ pnode->node_type == GA_NODE_SECONDARY_DOMAIN ||
+ pnode->node_type == GA_NODE_XFEM_PLUS ||
+ pnode->node_type == GA_NODE_XFEM_MINUS) {
std::string name = pnode->name;
size_type po = ga_parse_prefix_operator(name);
size_type pt = ga_parse_prefix_test(name);
for (size_type i = 0; i < params.size(); ++i)
- if (name.compare(params[i]) == 0) {
- pnode->name = name;
- switch(pnode->node_type) {
- case GA_NODE_NAME : pnode->op_type = GA_NAME; break;
- case GA_NODE_INTERPOLATE : pnode->op_type = GA_INTERPOLATE; break;
- case GA_NODE_ELEMENTARY : pnode->op_type = GA_ELEMENTARY; break;
- case GA_NODE_SECONDARY_DOMAIN :
+ if (name.compare(params[i]) == 0) {
+ pnode->name = name;
+ switch(pnode->node_type) {
+ case GA_NODE_NAME : pnode->op_type = GA_NAME; break;
+ case GA_NODE_INTERPOLATE : pnode->op_type = GA_INTERPOLATE; break;
+ case GA_NODE_ELEMENTARY : pnode->op_type = GA_ELEMENTARY; break;
+ case GA_NODE_SECONDARY_DOMAIN :
pnode->op_type = GA_SECONDARY_DOMAIN; break;
- case GA_NODE_XFEM_PLUS : pnode->op_type = GA_XFEM_PLUS; break;
- case GA_NODE_XFEM_MINUS: pnode->op_type = GA_XFEM_MINUS; break;
- default:break;
- }
- pnode->node_type = GA_NODE_MACRO_PARAM;
- pnode->nbc1 = i; pnode->nbc2 = po; pnode->nbc3 = pt;
- }
+ case GA_NODE_XFEM_PLUS : pnode->op_type = GA_XFEM_PLUS; break;
+ case GA_NODE_XFEM_MINUS: pnode->op_type = GA_XFEM_MINUS; break;
+ default:break;
+ }
+ pnode->node_type = GA_NODE_MACRO_PARAM;
+ pnode->nbc1 = i; pnode->nbc2 = po; pnode->nbc3 = pt;
+ }
}
}
static void ga_mark_macro_params(ga_macro &gam,
- const std::vector<std::string> ¶ms,
- const ga_macro_dictionnary ¯o_dict) {
+ const std::vector<std::string> ¶ms,
+ const ga_macro_dictionnary ¯o_dict) {
if (gam.tree().root) {
ga_mark_macro_params_rec(gam.tree().root, params);
ga_expand_macro(gam.tree(), gam.tree().root, macro_dict);
@@ -1459,7 +1458,7 @@ namespace getfem {
{ macros[gam.name()] = gam; }
void ga_macro_dictionnary::add_macro(const std::string &name,
- const std::string &expr)
+ const std::string &expr)
{ ga_tree tree; ga_read_string_reg("Def "+name+":="+expr, tree, *this); }
void ga_macro_dictionnary::del_macro(const std::string &name) {
@@ -1476,7 +1475,7 @@ namespace getfem {
// Read a term with an (implicit) pushdown automaton.
static GA_TOKEN_TYPE ga_read_term(pstring expr, size_type &pos,
ga_tree &tree,
- ga_macro_dictionnary ¯o_dict) {
+ ga_macro_dictionnary ¯o_dict) {
size_type token_pos, token_length;
GA_TOKEN_TYPE t_type;
int state = 1; // 1 = reading term, 2 = reading after term
@@ -1528,60 +1527,60 @@ namespace getfem {
tree.add_op(GA_DEVIATOR, token_pos, expr);
state = 1; break;
- case GA_DEF:
- {
- ga_macro gam;
- t_type = ga_get_token(*expr, pos, token_pos, token_length);
- if (t_type != GA_NAME)
+ case GA_DEF:
+ {
+ ga_macro gam;
+ t_type = ga_get_token(*expr, pos, token_pos, token_length);
+ if (t_type != GA_NAME)
ga_throw_error(expr, pos,
"Macro definition should begin with macro name");
- gam.name() = std::string(&((*expr)[token_pos]), token_length);
- if (ga_check_name_validity(gam.name()))
- ga_throw_error(expr, pos-1, "Invalid macro name.")
- t_type = ga_get_token(*expr, pos, token_pos, token_length);
- std::vector<std::string> params;
+ gam.name() = std::string(&((*expr)[token_pos]), token_length);
+ if (ga_check_name_validity(gam.name()))
+ ga_throw_error(expr, pos-1, "Invalid macro name.")
+ t_type = ga_get_token(*expr, pos, token_pos, token_length);
+ std::vector<std::string> params;
if (t_type == GA_LPAR) {
- t_type = ga_get_token(*expr, pos, token_pos, token_length);
- while (t_type == GA_NAME) {
- params.push_back(std::string(&((*expr)[token_pos]),
- token_length));
- if (ga_check_name_validity(params.back()))
- ga_throw_error(expr, pos-1, "Invalid macro parameter name.");
- for (size_type i = 0; i+1 < params.size(); ++i)
- if (params.back().compare(params[i]) == 0)
- ga_throw_error(expr, pos-1,
- "Invalid repeated macro parameter name.");
- t_type = ga_get_token(*expr, pos, token_pos, token_length);
- if (t_type == GA_COMMA)
- t_type = ga_get_token(*expr, pos, token_pos, token_length);
- }
- if (t_type != GA_RPAR)
- ga_throw_error(expr, pos-1,
- "Missing right parenthesis in macro definition.");
- t_type = ga_get_token(*expr, pos, token_pos, token_length);
- }
- if (t_type != GA_COLON_EQ)
- ga_throw_error(expr, pos-1, "Missing := for macro definition.");
-
- t_type = ga_read_term(expr, pos, gam.tree(), macro_dict);
- if (gam.tree().root)
- ga_expand_macro(gam.tree(), gam.tree().root, macro_dict);
- gam.nb_params() = params.size();
- if (params.size())
- ga_mark_macro_params(gam, params, macro_dict);
- macro_dict.add_macro(gam);
-
- // cout << "macro \"" << gam.name() << "\" registered with "
- // << gam.nb_params() << " params := "
- // << ga_tree_to_string(gam.tree()) << endl;
-
- if (t_type == GA_END) return t_type;
+ t_type = ga_get_token(*expr, pos, token_pos, token_length);
+ while (t_type == GA_NAME) {
+ params.push_back(std::string(&((*expr)[token_pos]),
+ token_length));
+ if (ga_check_name_validity(params.back()))
+ ga_throw_error(expr, pos-1, "Invalid macro parameter name.");
+ for (size_type i = 0; i+1 < params.size(); ++i)
+ if (params.back().compare(params[i]) == 0)
+ ga_throw_error(expr, pos-1,
+ "Invalid repeated macro parameter name.");
+ t_type = ga_get_token(*expr, pos, token_pos, token_length);
+ if (t_type == GA_COMMA)
+ t_type = ga_get_token(*expr, pos, token_pos, token_length);
+ }
+ if (t_type != GA_RPAR)
+ ga_throw_error(expr, pos-1,
+ "Missing right parenthesis in macro
definition.");
+ t_type = ga_get_token(*expr, pos, token_pos, token_length);
+ }
+ if (t_type != GA_COLON_EQ)
+ ga_throw_error(expr, pos-1, "Missing := for macro definition.");
+
+ t_type = ga_read_term(expr, pos, gam.tree(), macro_dict);
+ if (gam.tree().root)
+ ga_expand_macro(gam.tree(), gam.tree().root, macro_dict);
+ gam.nb_params() = params.size();
+ if (params.size())
+ ga_mark_macro_params(gam, params, macro_dict);
+ macro_dict.add_macro(gam);
+
+ // cout << "macro \"" << gam.name() << "\" registered with "
+ // << gam.nb_params() << " params := "
+ // << ga_tree_to_string(gam.tree()) << endl;
+
+ if (t_type == GA_END) return t_type;
else if (t_type != GA_SEMICOLON)
ga_throw_error(expr, pos-1,
- "Syntax error at the end of macro definition.");
- state = 1;
- }
- break;
+ "Syntax error at the end of macro definition.");
+ state = 1;
+ }
+ break;
case GA_INTERPOLATE:
{
@@ -1780,66 +1779,66 @@ namespace getfem {
size_type tensor_order(1);
bool foundcomma(false), foundsemi(false);
- r_type = ga_read_term(expr, pos, sub_tree, macro_dict);
- size_type nb_comp = 0;
- tree.add_matrix(token_pos, expr);
-
- if (sub_tree.root->node_type == GA_NODE_C_MATRIX) { // nested format
- bgeot::multi_index mii;
- do {
- if (nb_comp) {
- sub_tree.clear();
- r_type = ga_read_term(expr, pos, sub_tree, macro_dict);
- }
- // in the nested format only "," and "]" are expected
- if (sub_tree.root->node_type != GA_NODE_C_MATRIX ||
- (r_type != GA_COMMA && r_type != GA_RBRACKET))
+ r_type = ga_read_term(expr, pos, sub_tree, macro_dict);
+ size_type nb_comp = 0;
+ tree.add_matrix(token_pos, expr);
+
+ if (sub_tree.root->node_type == GA_NODE_C_MATRIX) { // nested
format
+ bgeot::multi_index mii;
+ do {
+ if (nb_comp) {
+ sub_tree.clear();
+ r_type = ga_read_term(expr, pos, sub_tree, macro_dict);
+ }
+ // in the nested format only "," and "]" are expected
+ if (sub_tree.root->node_type != GA_NODE_C_MATRIX ||
+ (r_type != GA_COMMA && r_type != GA_RBRACKET))
ga_throw_error(expr, pos-1, "Bad explicit "
"vector/matrix/tensor format.");
- // convert a row vector [a,b] to a column vector [a;b]
+ // convert a row vector [a,b] to a column vector [a;b]
if (sub_tree.root->marked &&
- sub_tree.root->tensor().sizes()[0] == 1 &&
- sub_tree.root->tensor().size() != 1) {
- bgeot::multi_index mi = sub_tree.root->tensor().sizes();
- for (size_type i = mi.size()-1; i > 0; i--)
- mi[i-1] = mi[i];
- mi.pop_back();
- sub_tree.root->tensor().adjust_sizes(mi);
- }
- if (!nb_comp) mii = sub_tree.root->tensor().sizes();
- else {
- const bgeot::multi_index &mi=sub_tree.root->tensor().sizes();
- bool cmp = true;
- if (mii.size() == mi.size()) {
- for (size_type i = 0; i < mi.size(); ++i)
- if (mi[i] != mii[i]) cmp = false;
- } else cmp = false;
- if (!cmp)
- ga_throw_error(expr, pos-1, "Bad explicit "
+ sub_tree.root->tensor().sizes()[0] == 1 &&
+ sub_tree.root->tensor().size() != 1) {
+ bgeot::multi_index mi = sub_tree.root->tensor().sizes();
+ for (size_type i = mi.size()-1; i > 0; i--)
+ mi[i-1] = mi[i];
+ mi.pop_back();
+ sub_tree.root->tensor().adjust_sizes(mi);
+ }
+ if (!nb_comp) mii = sub_tree.root->tensor().sizes();
+ else {
+ const bgeot::multi_index &mi=sub_tree.root->tensor().sizes();
+ bool cmp = true;
+ if (mii.size() == mi.size()) {
+ for (size_type i = 0; i < mi.size(); ++i)
+ if (mi[i] != mii[i]) cmp = false;
+ } else cmp = false;
+ if (!cmp)
+ ga_throw_error(expr, pos-1, "Bad explicit "
"vector/matrix/tensor format.");
- }
- for (size_type i = 0; i < sub_tree.root->children.size(); ++i) {
- sub_tree.root->children[i]->parent = tree.current_node;
- tree.current_node->children.push_back
- (sub_tree.root->children[i]);
- }
- sub_tree.root->children.resize(0);
- nb_comp++;
- } while (r_type != GA_RBRACKET);
- tree.current_node->marked = false;
- mii.push_back(nb_comp);
- tree.current_node->tensor().adjust_sizes(mii);
- } else { // non nested format
- do {
- if (nb_comp) {
- sub_tree.clear();
- r_type = ga_read_term(expr, pos, sub_tree, macro_dict);
- }
- nb_comp++;
-
- tree.add_sub_tree(sub_tree);
-
+ }
+ for (size_type i = 0; i < sub_tree.root->children.size(); ++i)
{
+ sub_tree.root->children[i]->parent = tree.current_node;
+ tree.current_node->children.push_back
+ (sub_tree.root->children[i]);
+ }
+ sub_tree.root->children.resize(0);
+ nb_comp++;
+ } while (r_type != GA_RBRACKET);
+ tree.current_node->marked = false;
+ mii.push_back(nb_comp);
+ tree.current_node->tensor().adjust_sizes(mii);
+ } else { // non nested format
+ do {
+ if (nb_comp) {
+ sub_tree.clear();
+ r_type = ga_read_term(expr, pos, sub_tree, macro_dict);
+ }
+ nb_comp++;
+
+ tree.add_sub_tree(sub_tree);
+
++n1; ++n2; ++n3;
if (tensor_order < 2) ++nbc1;
if (tensor_order < 3) ++nbc2;
@@ -1888,42 +1887,42 @@ namespace getfem {
"separated by ',', ';', ',,' and ';;' and "
"be ended by ']'.");
}
-
- } while (r_type != GA_RBRACKET);
- bgeot::multi_index mi;
- nbc1 = tree.current_node->nbc1; nbc2 = tree.current_node->nbc2;
- nbc3 = tree.current_node->nbc3;
-
- size_type nbl = tree.current_node->children.size()
- / (nbc2 * nbc1 * nbc3);
- switch(tensor_order) {
- case 1:
- /* mi.push_back(1); */ mi.push_back(nbc1); break;
- case 2:
- mi.push_back(nbl); if (nbc1 > 1) mi.push_back(nbc1); break;
- case 3:
- mi.push_back(nbl); mi.push_back(nbc2);
- mi.push_back(nbc1);
- break;
- case 4:
- mi.push_back(nbl); mi.push_back(nbc3);
- mi.push_back(nbc2); mi.push_back(nbc1);
- break;
- default: GMM_ASSERT1(false, "Internal error");
- }
- tree.current_node->tensor().adjust_sizes(mi);
- std::vector<pga_tree_node> children = tree.current_node->children;
- auto it = tree.current_node->children.begin();
- for (size_type i = 0; i < nbc1; ++i)
- for (size_type j = 0; j < nbc2; ++j)
- for (size_type k = 0; k < nbc3; ++k)
- for (size_type l = 0; l < nbl; ++l, ++it)
- *it = children[i+nbc1*(j+nbc2*(k+nbc3*l))];
- tree.current_node->marked = true;
- }
+
+ } while (r_type != GA_RBRACKET);
+ bgeot::multi_index mi;
+ nbc1 = tree.current_node->nbc1; nbc2 = tree.current_node->nbc2;
+ nbc3 = tree.current_node->nbc3;
+
+ size_type nbl = tree.current_node->children.size()
+ / (nbc2 * nbc1 * nbc3);
+ switch(tensor_order) {
+ case 1:
+ /* mi.push_back(1); */ mi.push_back(nbc1); break;
+ case 2:
+ mi.push_back(nbl); if (nbc1 > 1) mi.push_back(nbc1); break;
+ case 3:
+ mi.push_back(nbl); mi.push_back(nbc2);
+ mi.push_back(nbc1);
+ break;
+ case 4:
+ mi.push_back(nbl); mi.push_back(nbc3);
+ mi.push_back(nbc2); mi.push_back(nbc1);
+ break;
+ default: GMM_ASSERT1(false, "Internal error");
+ }
+ tree.current_node->tensor().adjust_sizes(mi);
+ std::vector<pga_tree_node> children =
tree.current_node->children;
+ auto it = tree.current_node->children.begin();
+ for (size_type i = 0; i < nbc1; ++i)
+ for (size_type j = 0; j < nbc2; ++j)
+ for (size_type k = 0; k < nbc3; ++k)
+ for (size_type l = 0; l < nbl; ++l, ++it)
+ *it = children[i+nbc1*(j+nbc2*(k+nbc3*l))];
+ tree.current_node->marked = true;
+ }
}
- tree.current_node->nbc1 = tree.current_node->tensor().sizes().size();
- state = 2;
+ tree.current_node->nbc1 = tree.current_node->tensor().sizes().size();
+ state = 2;
break;
default:
@@ -1973,7 +1972,7 @@ namespace getfem {
// Syntax analysis of a string. Conversion to a tree. register the macros.
void ga_read_string_reg(const std::string &expr, ga_tree &tree,
- ga_macro_dictionnary ¯o_dict) {
+ ga_macro_dictionnary ¯o_dict) {
size_type pos = 0, token_pos, token_length;
tree.clear();
GA_TOKEN_TYPE t = ga_get_token(expr, pos, token_pos, token_length);
@@ -1995,7 +1994,7 @@ namespace getfem {
// Syntax analysis of a string. Conversion to a tree.
// Do not register the macros (but expand them).
void ga_read_string(const std::string &expr, ga_tree &tree,
- const ga_macro_dictionnary ¯o_dict) {
+ const ga_macro_dictionnary ¯o_dict) {
ga_macro_dictionnary macro_dict_loc(true, macro_dict);
ga_read_string_reg(expr, tree, macro_dict_loc);
}
diff --git a/src/getfem_generic_assembly_workspace.cc
b/src/getfem_generic_assembly_workspace.cc
index af872ec..77f6a5c 100644
--- a/src/getfem_generic_assembly_workspace.cc
+++ b/src/getfem_generic_assembly_workspace.cc
@@ -80,7 +80,6 @@ namespace getfem {
gmm::vect_size(VV)/(imd.nb_filtered_index() * imd.nb_tensor_elem()));
}
-
bool ga_workspace::variable_exists(const std::string &name) const {
return (md && md->variable_exists(name)) ||
(parent_workspace && parent_workspace->variable_exists(name)) ||
@@ -216,7 +215,7 @@ namespace getfem {
size_type ga_workspace::qdim(const std::string &name) const {
VAR_SET::const_iterator it = variables.find(name);
if (it != variables.end()) {
- const mesh_fem *mf = it->second.is_fem_dofs ? it->second.mf : 0;
+ const mesh_fem *mf = it->second.is_fem_dofs ? it->second.mf : 0;
const im_data *imd = it->second.imd;
size_type n = it->second.qdim();
if (mf) {
@@ -475,8 +474,8 @@ namespace getfem {
for (const var_trans_pair &var : expr_variables) {
if (!(is_constant(var.varname))) {
ga_tree dtree = (remain ? tree : *(trees[ind_tree].ptree));
- // cout << "Derivation with respect to " << var.first << " : "
- // << var.second << " of " << ga_tree_to_string(dtree) << endl;
+ // cout << "Derivation with respect to " << var.varname << " : "
+ // << var.transname << " of " << ga_tree_to_string(dtree) <<
endl;
GA_TIC;
ga_derivative(dtree, *this, m, var.varname, var.transname,
1+order);
// cout << "Result : " << ga_tree_to_string(dtree) << endl;
diff --git a/src/getfem_mesh.cc b/src/getfem_mesh.cc
index edf8d96..e189e6e 100644
--- a/src/getfem_mesh.cc
+++ b/src/getfem_mesh.cc
@@ -363,7 +363,7 @@ namespace getfem {
}
bgeot::mesh_structure::sup_convex(ic);
if (sup_points)
- for (size_type ip = 0; ip < ipt.size(); ++ip) sup_point(ipt[ip]);
+ for (const size_type &ip : ipt) sup_point(ip);
trans_exists.sup(ic);
sup_convex_from_regions(ic);
if (Bank_info.get()) Bank_sup_convex_from_green(ic);
diff --git a/src/getfem_models.cc b/src/getfem_models.cc
index 4f55c21..1f7c6e1 100644
--- a/src/getfem_models.cc
+++ b/src/getfem_models.cc
@@ -1005,8 +1005,8 @@ namespace getfem {
for (size_type j = 0; j < bricks[ibb].mims.size(); ++j)
if (bricks[ibb].mims[j] == mim) found = true;
}
- for(VAR_SET::iterator it2 = variables.begin();
- it2 != variables.end(); ++it2) {
+ for (VAR_SET::iterator it2 = variables.begin();
+ it2 != variables.end(); ++it2) {
if (it2->second.is_fem_dofs &&
(it2->second.filter & VDESCRFILTER_INFSUP) &&
mim == it2->second.mim) found = true;
@@ -1906,22 +1906,16 @@ namespace getfem {
if (brick.is_update_brick) //contributions of pure update bricks must be
deleted
{
- for (size_type i = 0; i < brick.cmatlist.size(); ++i)
- {
- gmm::clear(brick.cmatlist[i]);
- }
+ for (auto &&mat : brick.cmatlist)
+ gmm::clear(mat);
- for (size_type i = 0; i < brick.cveclist.size(); ++i)
- for (size_type j = 0; j < brick.cveclist[i].size(); ++j)
- {
- gmm::clear(brick.cveclist[i][j]);
- }
+ for (auto &&vecs : brick.cveclist)
+ for (auto &&vec : vecs)
+ gmm::clear(vec);
- for (size_type i = 0; i < brick.cveclist_sym.size(); ++i)
- for (size_type j = 0; j < brick.cveclist_sym[i].size(); ++j)
- {
- gmm::clear(brick.cveclist_sym[i][j]);
- }
+ for (auto &&vecs : brick.cveclist_sym)
+ for (auto &&vec : vecs)
+ gmm::clear(vec);
}
}
else //not cplx
@@ -1966,22 +1960,16 @@ namespace getfem {
if (brick.is_update_brick) //contributions of pure update bricks must be
deleted
{
- for (size_type i = 0; i < brick.rmatlist.size(); ++i)
- {
- gmm::clear(brick.rmatlist[i]);
- }
+ for (auto &&mat : brick.rmatlist)
+ gmm::clear(mat);
- for (size_type i = 0; i < brick.rveclist.size(); ++i)
- for (size_type j = 0; j < brick.rveclist[i].size(); ++j)
- {
- gmm::clear(brick.rveclist[i][j]);
- }
+ for (auto &&vecs : brick.rveclist)
+ for (auto &&vec : vecs)
+ gmm::clear(vec);
- for (size_type i = 0; i < brick.rveclist_sym.size(); ++i)
- for (size_type j = 0; j < brick.rveclist_sym[i].size(); ++j)
- {
- gmm::clear(brick.rveclist_sym[i][j]);
- }
+ for (auto &&vecs : brick.rveclist_sym)
+ for (auto &&vec : vecs)
+ gmm::clear(vec);
}
}
}
@@ -2583,7 +2571,7 @@ namespace getfem {
if (brick.pbr->is_linear()
&& (!is_linear() || (version & BUILD_WITH_COMPLETE_RHS))) {
gmm::mult_add(gmm::transposed(brick.rmatlist[j]),
- gmm::scaled(it1->second.complex_value[0],
+ gmm::scaled(it1->second.complex_value[0],
complex_type(-alpha2)),
gmm::sub_vector(crhs, I2));
}
@@ -2731,8 +2719,8 @@ namespace getfem {
exception.rethrow();
} //end of distro scope
- if (version & BUILD_RHS) gmm::add(gmm::scaled(residual,
scalar_type(-1)), rrhs);
-
+ if (version & BUILD_RHS)
+ gmm::add(gmm::scaled(residual, scalar_type(-1)), rrhs);
}
// Post simplification for dof constraints