[Getfem-commits] (no subject)

[Konstantinos Poulios]

branch: devel-logari81-internal-variables
commit fb27f37675ffd7d6c8a0a12bd1c6cbaa255dacdd
Author: Konstantinos Poulios <address@hidden>
Date:   Thu Jan 2 11:05:11 2020 +0100

    Refactor inheritance of model disabled variables by ga_workspace
---
 src/getfem/getfem_generic_assembly.h     | 10 ++--
 src/getfem_generic_assembly_workspace.cc | 84 +++++++++++++++++---------------
 src/getfem_models.cc                     | 45 ++++-------------
 3 files changed, 57 insertions(+), 82 deletions(-)

diff --git a/src/getfem/getfem_generic_assembly.h 
b/src/getfem/getfem_generic_assembly.h
index e6d872e..3f47eaa 100644
--- a/src/getfem/getfem_generic_assembly.h
+++ b/src/getfem/getfem_generic_assembly.h
@@ -264,7 +264,6 @@ namespace getfem {
 
     const model *md;
     const ga_workspace *parent_workspace;
-    bool enable_all_md_variables;
     size_type nb_prim_dof, nb_tmp_dof;
 
     void init();
@@ -343,8 +342,8 @@ namespace getfem {
     typedef std::map<std::string, var_description> VAR_SET;
     VAR_SET variables;
 
-    mutable std::map<std::string, gmm::sub_interval> int_disabled_variables;
-    std::map<std::string, gmm::sub_interval> tmp_var_intervals;
+    std::map<std::string, gmm::sub_interval> reenabled_var_intervals,
+                                             tmp_var_intervals;
 
     std::map<std::string, pinterpolate_transformation> transformations;
     std::map<std::string, pelementary_transformation> elem_transformations;
@@ -486,9 +485,6 @@ namespace getfem {
     const scalar_type &factor_of_variable(const std::string &name) const;
 
     const gmm::sub_interval &
-    interval_of_disabled_variable(const std::string &name) const;
-
-    const gmm::sub_interval &
     interval_of_variable(const std::string &name) const;
 
     const mesh_fem *associated_mf(const std::string &name) const;
@@ -570,7 +566,7 @@ namespace getfem {
       return (it != tmp_var_intervals.end()) ? it->second : empty_interval;
     }
 
-    ga_workspace(const getfem::model &md_, bool enable_all_variables = false);
+    ga_workspace(const getfem::model &md_, bool 
enable_disabled_variables=false);
     ga_workspace(bool, const ga_workspace &gaw);
     ga_workspace();
     ~ga_workspace();
diff --git a/src/getfem_generic_assembly_workspace.cc 
b/src/getfem_generic_assembly_workspace.cc
index 756f1fe..330d1db 100644
--- a/src/getfem_generic_assembly_workspace.cc
+++ b/src/getfem_generic_assembly_workspace.cc
@@ -124,28 +124,30 @@ namespace getfem {
 
   bool ga_workspace::is_constant(const std::string &name) const {
     VAR_SET::const_iterator it = variables.find(name);
-    if (it != variables.end()) return !(it->second.is_variable);
-    if (variable_group_exists(name))
+    if (it != variables.end())
+      return !(it->second.is_variable);
+    else if (variable_group_exists(name))
       return is_constant(first_variable_of_group(name));
-    if (md && md->variable_exists(name)) {
-      if (enable_all_md_variables) return md->is_true_data(name);
+    else if (reenabled_var_intervals.count(name))
+      return false;
+    else if (md && md->variable_exists(name))
       return md->is_data(name);
-    }
-    if (parent_workspace && parent_workspace->variable_exists(name))
+    else if (parent_workspace && parent_workspace->variable_exists(name))
       return parent_workspace->is_constant(name);
     GMM_ASSERT1(false, "Undefined variable " << name);
   }
 
   bool ga_workspace::is_disabled_variable(const std::string &name) const {
     VAR_SET::const_iterator it = variables.find(name);
-    if (it != variables.end()) return false;
-    if (variable_group_exists(name))
+    if (it != variables.end())
+      return false;
+    else if (variable_group_exists(name))
       return is_disabled_variable(first_variable_of_group(name));
-    if (md && md->variable_exists(name)) {
-      if (enable_all_md_variables) return false;
+    else if (reenabled_var_intervals.count(name))
+      return false;
+    else if (md && md->variable_exists(name))
       return md->is_disabled_variable(name);
-    }
-    if (parent_workspace && parent_workspace->variable_exists(name))
+    else if (parent_workspace && parent_workspace->variable_exists(name))
       return parent_workspace->is_disabled_variable(name);
     GMM_ASSERT1(false, "Undefined variable " << name);
   }
@@ -164,33 +166,14 @@ namespace getfem {
   }
 
   const gmm::sub_interval &
-  ga_workspace::interval_of_disabled_variable(const std::string &name) const {
-    std::map<std::string, gmm::sub_interval>::const_iterator
-      it1 = int_disabled_variables.find(name);
-    if (it1 != int_disabled_variables.end()) return it1->second;
-    if (md->is_affine_dependent_variable(name))
-      return interval_of_disabled_variable(md->org_variable(name));
-
-    size_type first = md->nb_dof();
-    for (const std::pair<std::string, gmm::sub_interval> &p
-         : int_disabled_variables)
-      first = std::max(first, p.second.last());
-
-    int_disabled_variables[name]
-      = gmm::sub_interval(first, gmm::vect_size(value(name)));
-    return int_disabled_variables[name];
-  }
-
-  const gmm::sub_interval &
   ga_workspace::interval_of_variable(const std::string &name) const {
     VAR_SET::const_iterator it = variables.find(name);
     if (it != variables.end()) return it->second.I;
-    if (md && md->variable_exists(name)) {
-      if (enable_all_md_variables && md->is_disabled_variable(name))
-        return interval_of_disabled_variable(name);
+    const auto it2 = reenabled_var_intervals.find(name);
+    if (it2 != reenabled_var_intervals.end()) return it2->second;
+    if (md && md->variable_exists(name))
       return md->interval_of_variable(name);
-    }
-    if (parent_workspace && parent_workspace->variable_exists(name))
+    else if (parent_workspace && parent_workspace->variable_exists(name))
       return parent_workspace->interval_of_variable(name);
     GMM_ASSERT1(false, "Undefined variable " << name);
   }
@@ -921,23 +904,44 @@ namespace getfem {
   { if (ptree) delete ptree; ptree = 0; }
 
   ga_workspace::ga_workspace(const getfem::model &md_,
-                             bool enable_all_variables)
+                             bool enable_disabled_variables)
     : md(&md_), parent_workspace(0),
-      enable_all_md_variables(enable_all_variables),
       nb_prim_dof(0), nb_tmp_dof(0),
       macro_dict(md_.macro_dictionary())
   {
     init();
     nb_prim_dof = md->nb_dof();
+    if (enable_disabled_variables) {
+      model::varnamelist vlmd;
+      md->variable_list(vlmd);
+      for (const auto &varname : vlmd)
+        if (md->is_disabled_variable(varname)) {
+          if (md->is_affine_dependent_variable(varname)) {
+            std::string orgvarname = md->org_variable(varname);
+            if (reenabled_var_intervals.count(orgvarname) == 0) {
+              size_type varsize = 
gmm::vect_size(md->real_variable(orgvarname));
+              reenabled_var_intervals[orgvarname]
+                = gmm::sub_interval (nb_prim_dof, varsize);
+              nb_prim_dof += varsize;
+            }
+            reenabled_var_intervals[varname]
+              = reenabled_var_intervals[orgvarname];
+          } else  if (reenabled_var_intervals.count(varname) == 0) {
+            size_type varsize = gmm::vect_size(md->real_variable(varname));
+            reenabled_var_intervals[varname]
+              = gmm::sub_interval(nb_prim_dof, varsize);
+            nb_prim_dof += varsize;
+          }
+        }
+    }
   }
   ga_workspace::ga_workspace(bool, const ga_workspace &gaw)
-    : md(0), parent_workspace(&gaw), enable_all_md_variables(false),
+    : md(0), parent_workspace(&gaw),
       nb_prim_dof(gaw.nb_primary_dof()), nb_tmp_dof(0),
       macro_dict(gaw.macro_dictionary())
   { init(); }
   ga_workspace::ga_workspace()
-    : md(0), parent_workspace(0), enable_all_md_variables(false),
-      nb_prim_dof(0), nb_tmp_dof(0)
+    : md(0), parent_workspace(0), nb_prim_dof(0), nb_tmp_dof(0)
   { init(); }
   ga_workspace::~ga_workspace() { clear_expressions(); }
 
diff --git a/src/getfem_models.cc b/src/getfem_models.cc
index 82a29fe..d782fd3 100644
--- a/src/getfem_models.cc
+++ b/src/getfem_models.cc
@@ -213,12 +213,11 @@ namespace getfem {
   }
 
   bool model::is_true_data(const std::string &name) const {
-    return is_old(name) ? true : !variable_description(name).is_variable;
+    return is_old(name) || !(variable_description(name).is_variable);
   }
 
   bool model::is_affine_dependent_variable(const std::string &name) const {
-    return is_old(name) ? false
-                        : variable_description(name).is_affine_dependent;
+    return !(is_old(name)) && variable_description(name).is_affine_dependent;
   }
 
   const std::string &
@@ -3172,21 +3171,11 @@ namespace getfem {
         ga_workspace workspace(md, true);
         GMM_TRACE2(name << ": generic source term assembly");
         workspace.add_expression(expr, *(mims[0]), region, 1, 
secondary_domain);
-        size_type nbgdof = md.nb_dof();
-        {
-          model::varnamelist vlmd;
-          md.variable_list(vlmd);
-          for (const auto &varname : vlmd)
-            if (md.is_disabled_variable(varname))
-              nbgdof = std::max(nbgdof,
-                                
workspace.interval_of_variable(varname).last());
-        }
-        model_real_plain_vector V(nbgdof);
-        workspace.set_assembled_vector(V);
         workspace.assembly(1);
+        const auto &V=workspace.assembled_vector();
         for (size_type i = 0; i < vl_test1.size(); ++i) {
-          gmm::copy(gmm::sub_vector
-                    (V, workspace.interval_of_variable(vl_test1[i])), vecl[i]);
+          const auto &I=workspace.interval_of_variable(vl_test1[i]);
+          gmm::copy(gmm::sub_vector(V, I), vecl[i]);
         }
       }
 
@@ -3334,25 +3323,18 @@ namespace getfem {
           md.is_var_newer_than_brick(dl[i], ib);
 
       if (recompute_matrix) {
-        size_type nbgdof = md.nb_dof();
         ga_workspace workspace(md, true);
         workspace.add_expression(expr, *(mims[0]), region, 2, 
secondary_domain);
-        model::varnamelist vlmd; md.variable_list(vlmd);
-        for (size_type i = 0; i < vlmd.size(); ++i)
-          if (md.is_disabled_variable(vlmd[i]))
-            nbgdof = std::max(nbgdof,
-                              workspace.interval_of_variable(vlmd[i]).last());
         GMM_TRACE2(name << ": generic matrix assembly");
-        model_real_sparse_matrix R(nbgdof, nbgdof);
-        workspace.set_assembled_matrix(R);
         workspace.assembly(2);
+        const auto &R=workspace.assembled_matrix();
         for (size_type i = 0; i < vl_test1.size(); ++i) {
           scalar_type alpha = scalar_type(1)
             / ( workspace.factor_of_variable(vl_test1[i]) *
                 workspace.factor_of_variable(vl_test2[i]));
-          gmm::copy(gmm::scaled(gmm::sub_matrix
-                    (R, workspace.interval_of_variable(vl_test1[i]),
-                     workspace.interval_of_variable(vl_test2[i])), alpha),
+          const auto &I1=workspace.interval_of_variable(vl_test1[i]),
+                     &I2=workspace.interval_of_variable(vl_test2[i]);
+          gmm::copy(gmm::scaled(gmm::sub_matrix(R, I1, I2), alpha),
                     matl[i]);
         }
       }
@@ -5915,20 +5897,13 @@ namespace getfem {
       }
 
       if (recompute_matrix) {
-        size_type nbgdof = md.nb_dof();
         ga_workspace workspace(md, true);
         workspace.add_expression(expr, *(mims[0]), region);
         GMM_TRACE2(name << ": generic matrix assembly");
-        model::varnamelist vlmd; md.variable_list(vlmd);
-        for (size_type i = 0; i < vlmd.size(); ++i)
-          if (md.is_disabled_variable(vlmd[i]))
-            nbgdof = std::max(nbgdof,
-                              workspace.interval_of_variable(vlmd[i]).last());
-        model_real_sparse_matrix R(nbgdof, nbgdof);
-        workspace.set_assembled_matrix(R);
         workspace.assembly(2);
         scalar_type alpha = scalar_type(1)
           / (workspace.factor_of_variable(vl[0]));
+        const auto &R=workspace.assembled_matrix();
         gmm::sub_interval I = workspace.interval_of_variable(vl[0]);
         gmm::copy(gmm::scaled(gmm::sub_matrix(R, I, I), alpha),
                   matl[0]);