Construct linalg matrix with enum

Author: bwirthl

src/ale/4C_ale_ale2_evaluate.cpp

@@ -1139,12 +1139,12 @@ void Discret::Elements::Ale2::material_response3d_plane(Core::LinAlg::SerialDens
     Teuchos::ParameterList& params, const int gp)
 {
   // make 3d equivalent of Green-Lagrange strain
-  Core::LinAlg::Matrix<6, 1> gl(false);
+  Core::LinAlg::Matrix<6, 1> gl(Core::LinAlg::Initialization::uninitialized);
   green_lagrange_plane3d(strain, gl);
 
   // call 3d stress response
-  Core::LinAlg::Matrix<6, 1> pk2(true);   // must be zerofied!!!
-  Core::LinAlg::Matrix<6, 6> cmat(true);  // must be zerofied!!!
+  Core::LinAlg::Matrix<6, 1> pk2(Core::LinAlg::Initialization::zero);   // must be zerofied!!!
+  Core::LinAlg::Matrix<6, 6> cmat(Core::LinAlg::Initialization::zero);  // must be zerofied!!!
   material_response3d(&pk2, &cmat, &gl, params, gp);
 
   // we have plain strain

src/ale/4C_ale_ale3_evaluate.cpp

@@ -1377,7 +1377,7 @@ void Discret::Elements::Ale3Impl<distype>::static_ke_nonlinear(Ale3* ele,
   // --------------------------------------------------
   // Now do the nurbs specific stuff
   std::vector<Core::LinAlg::SerialDenseVector> myknots;
-  Core::LinAlg::Matrix<iel, 1> weights(iel);
+  Core::LinAlg::Matrix<iel, 1> weights;
 
   if (distype == Core::FE::CellType::nurbs8 || distype == Core::FE::CellType::nurbs27)
   {
@@ -1406,7 +1406,7 @@ void Discret::Elements::Ale3Impl<distype>::static_ke_nonlinear(Ale3* ele,
   Core::LinAlg::Matrix<3, 3> xjm;
   Core::LinAlg::Matrix<3, 3> xji;
   Core::LinAlg::Matrix<6, numdof> bop;
-  Core::LinAlg::Matrix<6, 6> D(true);
+  Core::LinAlg::Matrix<6, 6> D(Core::LinAlg::Initialization::zero);
   // gaussian points
   const Core::FE::GaussRule3D gaussrule = get_optimal_gaussrule();
   const Core::FE::IntegrationPoints3D intpoints(gaussrule);
@@ -1518,8 +1518,9 @@ void Discret::Elements::Ale3Impl<distype>::static_ke_nonlinear(Ale3* ele,
       bop(5, NODDOF_ALE3 * i + 2) = defgrd(2, 2) * N_XYZ(0, i) + defgrd(2, 0) * N_XYZ(2, i);
     }
     // call material law cccccccccccccccccccccccccccccccccccccccccccccccccccccc
-    Core::LinAlg::Matrix<Mat::NUM_STRESS_3D, Mat::NUM_STRESS_3D> cmat_f(true);
-    Core::LinAlg::Matrix<Mat::NUM_STRESS_3D, 1> stress_f(true);
+    Core::LinAlg::Matrix<Mat::NUM_STRESS_3D, Mat::NUM_STRESS_3D> cmat_f(
+        Core::LinAlg::Initialization::zero);
+    Core::LinAlg::Matrix<Mat::NUM_STRESS_3D, 1> stress_f(Core::LinAlg::Initialization::zero);
     Core::LinAlg::Matrix<Mat::NUM_STRESS_3D, 1> glstrain_f(glstrain.data());
     // QUICK HACK until so_disp exclusively uses Core::LinAlg::Matrix!!!!!
     Core::LinAlg::Matrix<NUMDIM_ALE3, NUMDIM_ALE3> fixed_defgrd(defgrd);
@@ -1612,7 +1613,7 @@ void Discret::Elements::Ale3Impl<distype>::static_ke_laplace(Ale3* ele,
   // --------------------------------------------------
   // Now do the nurbs specific stuff
   std::vector<Core::LinAlg::SerialDenseVector> myknots(3);
-  Core::LinAlg::Matrix<iel, 1> weights(iel);
+  Core::LinAlg::Matrix<iel, 1> weights;
 
   if (distype == Core::FE::CellType::nurbs8 or distype == Core::FE::CellType::nurbs27)
   {
@@ -1633,13 +1634,13 @@ void Discret::Elements::Ale3Impl<distype>::static_ke_laplace(Ale3* ele,
   }
 
   /*----------------------------------------- declaration of variables ---*/
-  Core::LinAlg::Matrix<iel, 1> funct(true);
-  Core::LinAlg::Matrix<3, iel> deriv(true);
-  Core::LinAlg::Matrix<3, 3> xjm(true);
-  Core::LinAlg::Matrix<3, 3> xji(true);
-  Core::LinAlg::Matrix<3, iel> deriv_xy(true);
-  Core::LinAlg::Matrix<iel, iel> tempmat(true);
-  Core::LinAlg::Matrix<3 * iel, 1> tempmat2(true);
+  Core::LinAlg::Matrix<iel, 1> funct(Core::LinAlg::Initialization::zero);
+  Core::LinAlg::Matrix<3, iel> deriv(Core::LinAlg::Initialization::zero);
+  Core::LinAlg::Matrix<3, 3> xjm(Core::LinAlg::Initialization::zero);
+  Core::LinAlg::Matrix<3, 3> xji(Core::LinAlg::Initialization::zero);
+  Core::LinAlg::Matrix<3, iel> deriv_xy(Core::LinAlg::Initialization::zero);
+  Core::LinAlg::Matrix<iel, iel> tempmat(Core::LinAlg::Initialization::zero);
+  Core::LinAlg::Matrix<3 * iel, 1> tempmat2(Core::LinAlg::Initialization::zero);
 
   // gaussian points
   const Core::FE::GaussRule3D gaussrule = get_optimal_gaussrule();

src/art_net/4C_art_net_artery_ele_calc_pres_based.cpp

@@ -139,7 +139,7 @@ void Discret::Elements::ArteryEleCalcPresBased<distype>::sysmat(Artery* ele,
   if (pressnp == nullptr) FOUR_C_THROW("could not get pressure inside artery element");
 
   // extract local values of pressure field from global state vector
-  Core::LinAlg::Matrix<my::iel_, 1> mypress(true);
+  Core::LinAlg::Matrix<my::iel_, 1> mypress(Core::LinAlg::Initialization::zero);
   Core::FE::extract_my_values<Core::LinAlg::Matrix<my::iel_, 1>>(*pressnp, mypress, la[0].lm_);
 
   // calculate the element length
@@ -217,7 +217,7 @@ void Discret::Elements::ArteryEleCalcPresBased<distype>::evaluate_flow(Artery* e
   if (pressnp == nullptr) FOUR_C_THROW("could not get pressure inside artery element");
 
   // extract local values of pressure field from global state vector
-  Core::LinAlg::Matrix<my::iel_, 1> mypress(true);
+  Core::LinAlg::Matrix<my::iel_, 1> mypress(Core::LinAlg::Initialization::zero);
   Core::FE::extract_my_values<Core::LinAlg::Matrix<my::iel_, 1>>(*pressnp, mypress, la[0].lm_);
 
   // calculate the element length

src/beam3/4C_beam3_base.cpp

@@ -325,10 +325,9 @@ void Discret::Elements::Beam3Base::un_shift_node_position(
 
   // loop through all nodes except for the first node which remains
   // fixed as reference node
-  static Core::LinAlg::Matrix<3, 1> d(true), ref(true), X(true);
-  d.clear();
-  ref.clear();
-  X.clear();
+  static Core::LinAlg::Matrix<3, 1> d(Core::LinAlg::Initialization::zero);
+  static Core::LinAlg::Matrix<3, 1> ref(Core::LinAlg::Initialization::zero);
+  static Core::LinAlg::Matrix<3, 1> X(Core::LinAlg::Initialization::zero);
   for (unsigned int i = 1; i < nnodecl; ++i)
   {
     for (int dim = 0; dim < 3; ++dim)
@@ -365,10 +364,9 @@ void Discret::Elements::Beam3Base::get_directions_of_shifts(std::vector<double>&
 
   // loop through all nodes except for the first node which remains
   // fixed as reference node
-  static Core::LinAlg::Matrix<3, 1> d(true), ref(true), X(true);
-  d.clear();
-  ref.clear();
-  X.clear();
+  static Core::LinAlg::Matrix<3, 1> d(Core::LinAlg::Initialization::zero);
+  static Core::LinAlg::Matrix<3, 1> ref(Core::LinAlg::Initialization::zero);
+  static Core::LinAlg::Matrix<3, 1> X(Core::LinAlg::Initialization::zero);
   for (unsigned int i = 1; i < nnodecl; ++i)
   {
     for (int dim = 0; dim < 3; ++dim)

src/beam3/4C_beam3_base.templates.hpp

@@ -19,7 +19,7 @@ template <unsigned int nnode, unsigned int vpernode>
 double Discret::Elements::Beam3Base::calc_reflength(
     const Core::LinAlg::Matrix<3 * vpernode * nnode, 1, double>& disp_refe_centerline)
 {
-  Core::LinAlg::Matrix<3, 1> tempvec(true);
+  Core::LinAlg::Matrix<3, 1> tempvec(Core::LinAlg::Initialization::zero);
 
   for (int dim = 0; dim < 3; dim++)
     tempvec(dim) = disp_refe_centerline(3 * vpernode * 1 + dim) - disp_refe_centerline(dim);

src/beam3/4C_beam3_discretization_runtime_vtu_writer.cpp

@@ -161,8 +161,8 @@ void BeamDiscretizationRuntimeOutputWriter::set_geometry_from_beam_discretizatio
 
     /* loop over the chosen visualization points (equidistant distribution in the element
      * parameter space xi \in [-1,1] ) and determine their interpolated (initial) positions r */
-    Core::LinAlg::Matrix<3, 1> interpolated_position(true);
-    Core::LinAlg::Matrix<3, 1> interpolated_position_priorpoint(true);
+    Core::LinAlg::Matrix<3, 1> interpolated_position(Core::LinAlg::Initialization::zero);
+    Core::LinAlg::Matrix<3, 1> interpolated_position_priorpoint(Core::LinAlg::Initialization::zero);
     double xi = 0.0;
 
     for (unsigned int ipoint = 0; ipoint < n_subsegments_ + 1; ++ipoint)
@@ -1357,7 +1357,7 @@ void BeamDiscretizationRuntimeOutputWriter::append_element_orientation_parameter
 
     // length of element is approximated linearly, as also the direction of a element is calculated
     // linearly independent of centerline interpolation
-    Core::LinAlg::Matrix<3, 1> dirvec(true);
+    Core::LinAlg::Matrix<3, 1> dirvec(Core::LinAlg::Initialization::zero);
 
     std::vector<double> pos(2, 0.0);
     for (int dim = 0; dim < 3; ++dim)
@@ -1375,7 +1375,7 @@ void BeamDiscretizationRuntimeOutputWriter::append_element_orientation_parameter
     double curr_lin_ele_length = dirvec.norm2();
 
     // loop over all base vectors for orientation index x,y and z
-    Core::LinAlg::Matrix<3, 1> unit_base_vec(true);
+    Core::LinAlg::Matrix<3, 1> unit_base_vec(Core::LinAlg::Initialization::zero);
     std::vector<double> curr_ele_orientation_parameter(3, 0.0);
     for (int unsigned ibase = 0; ibase < 3; ++ibase)
     {
@@ -1454,12 +1454,12 @@ void BeamDiscretizationRuntimeOutputWriter::append_rve_crosssection_forces(
   std::vector<std::vector<double>> fint_sum(3, std::vector<double>(3, 0.0));
   std::vector<double> beamelement_displacement_vector;
   std::vector<double> beamelement_shift_displacement_vector;
-  Core::LinAlg::Matrix<3, 1> pos_node_1(true);
-  Core::LinAlg::Matrix<3, 1> pos_node_2(true);
+  Core::LinAlg::Matrix<3, 1> pos_node_1(Core::LinAlg::Initialization::zero);
+  Core::LinAlg::Matrix<3, 1> pos_node_2(Core::LinAlg::Initialization::zero);
 
   // create pseudo planes through center of RVE (like this it also works if
   // your box is not periodic, i.e. you do not have cut element on the box edges)
-  Core::LinAlg::Matrix<3, 2> box(true);
+  Core::LinAlg::Matrix<3, 2> box(Core::LinAlg::Initialization::zero);
   if (periodic_boundingbox_ != nullptr)
   {
     for (unsigned dim = 0; dim < 3; ++dim)
@@ -1470,7 +1470,7 @@ void BeamDiscretizationRuntimeOutputWriter::append_rve_crosssection_forces(
     }
   }
 
-  Core::LinAlg::Matrix<3, 1> xi_intersect(true);
+  Core::LinAlg::Matrix<3, 1> xi_intersect(Core::LinAlg::Initialization::zero);
 
   // loop over all my elements and build force sum of myrank's cut element
   for (unsigned int ibeamele = 0; ibeamele < num_beam_row_elements; ++ibeamele)

src/beam3/4C_beam3_euler_bernoulli.cpp

@@ -97,7 +97,7 @@ Core::LinAlg::SerialDenseMatrix Discret::Elements::Beam3ebType::compute_null_spa
 
   // Compute tangent vector with unit length from nodal coordinates.
   // Note: Tangent vector is the same at both nodes due to straight initial configuration.
-  Core::LinAlg::Matrix<spacedim, 1> tangent(true);
+  Core::LinAlg::Matrix<spacedim, 1> tangent(Core::LinAlg::Initialization::zero);
   {
     const Core::Nodes::Node* firstnode = beam3eb->nodes()[0];
     const Core::Nodes::Node* secondnode = beam3eb->nodes()[1];
@@ -110,11 +110,11 @@ Core::LinAlg::SerialDenseMatrix Discret::Elements::Beam3ebType::compute_null_spa
 
   // Form a Cartesian basis
   std::array<Core::LinAlg::Matrix<spacedim, 1>, spacedim> basis;
-  Core::LinAlg::Matrix<spacedim, 1> e1(true);
+  Core::LinAlg::Matrix<spacedim, 1> e1(Core::LinAlg::Initialization::zero);
   e1(0) = 1.0;
-  Core::LinAlg::Matrix<spacedim, 1> e2(true);
+  Core::LinAlg::Matrix<spacedim, 1> e2(Core::LinAlg::Initialization::zero);
   e2(1) = 1.0;
-  Core::LinAlg::Matrix<spacedim, 1> e3(true);
+  Core::LinAlg::Matrix<spacedim, 1> e3(Core::LinAlg::Initialization::zero);
   e3(2) = 1.0;
   basis[0] = e1;
   basis[1] = e2;
@@ -148,16 +148,18 @@ Core::LinAlg::SerialDenseMatrix Discret::Elements::Beam3ebType::compute_null_spa
   if (std::abs(omegaTwo.dot(tangent)) > 1.0e-12)
     FOUR_C_THROW("omegaTwo not orthogonal to tangent vector.");
 
-  Core::LinAlg::Matrix<3, 1> nodeCoords(true);
+  Core::LinAlg::Matrix<3, 1> nodeCoords(Core::LinAlg::Initialization::zero);
   for (std::size_t dim = 0; dim < 3; ++dim) nodeCoords(dim) = x[dim] - x0[dim];
 
   // Compute rotations in displacement DOFs
-  Core::LinAlg::Matrix<spacedim, 1> rotOne(true), rotTwo(true);
+  Core::LinAlg::Matrix<spacedim, 1> rotOne(Core::LinAlg::Initialization::zero);
+  Core::LinAlg::Matrix<spacedim, 1> rotTwo(Core::LinAlg::Initialization::zero);
   rotOne.cross_product(omegaOne, nodeCoords);
   rotTwo.cross_product(omegaTwo, nodeCoords);
 
   // Compute rotations in tangent DOFs
-  Core::LinAlg::Matrix<spacedim, 1> rotTangOne(true), rotTangTwo(true);
+  Core::LinAlg::Matrix<spacedim, 1> rotTangOne(Core::LinAlg::Initialization::zero);
+  Core::LinAlg::Matrix<spacedim, 1> rotTangTwo(Core::LinAlg::Initialization::zero);
   rotTangOne.cross_product(omegaOne, tangent);
   rotTangTwo.cross_product(omegaTwo, tangent);
 
@@ -285,10 +287,10 @@ Discret::Elements::Beam3eb::Beam3eb(int id, int owner)
       firstcall_(true),
       ekin_(0.0),
       eint_(0.0),
-      l_(Core::LinAlg::Matrix<3, 1>(true)),
-      p_(Core::LinAlg::Matrix<3, 1>(true)),
-      t0_(Core::LinAlg::Matrix<3, 2>(true)),
-      t_(Core::LinAlg::Matrix<3, 2>(true)),
+      l_(Core::LinAlg::Matrix<3, 1>(Core::LinAlg::Initialization::zero)),
+      p_(Core::LinAlg::Matrix<3, 1>(Core::LinAlg::Initialization::zero)),
+      t0_(Core::LinAlg::Matrix<3, 2>(Core::LinAlg::Initialization::zero)),
+      t_(Core::LinAlg::Matrix<3, 2>(Core::LinAlg::Initialization::zero)),
       kappa_max_(0.0),
       epsilon_max_(0.0),
       axial_strain_gp_(0),
@@ -535,7 +537,7 @@ void Discret::Elements::Beam3eb::get_pos_at_xi(
         disp.size());
 
   // add reference positions and tangents => total Lagrangean state vector
-  Core::LinAlg::Matrix<12, 1> disp_totlag(true);
+  Core::LinAlg::Matrix<12, 1> disp_totlag(Core::LinAlg::Initialization::zero);
   update_disp_totlag<2, 6>(disp, disp_totlag);
 
   Beam3Base::get_pos_at_xi<2, 2, double>(pos, xi, disp_totlag);
@@ -553,7 +555,7 @@ void Discret::Elements::Beam3eb::get_triad_at_xi(
         disp.size());
 
   // add reference positions and tangents => total Lagrangean state vector
-  Core::LinAlg::Matrix<12, 1> disp_totlag(true);
+  Core::LinAlg::Matrix<12, 1> disp_totlag(Core::LinAlg::Initialization::zero);
   update_disp_totlag<2, 6>(disp, disp_totlag);
 
   triad.clear();