KratosMultiphysics
KRATOS Multiphysics (Kratos) is a framework for building parallel, multi-disciplinary simulation software, aiming at modularity, extensibility, and high performance. Kratos is written in C++, and counts with an extensive Python interface.
pure_convection_CrankN_tools.h
Go to the documentation of this file.
1 // KRATOS ___ ___ _ ___ __ ___ ___ ___ ___
2 // / __/ _ \| \| \ \ / /__| \_ _| __| __|
3 // | (_| (_) | .` |\ V /___| |) | || _|| _|
4 // \___\___/|_|\_| \_/ |___/___|_| |_| APPLICATION
5 //
6 // License: BSD License
7 // Kratos default license: kratos/license.txt
8 //
9 // Main authors: Antonia Larese
10 //
11 
12 #if !defined(KRATOS_PURE_CONVECTION_CRANKN_UTILITIES_INCLUDED )
13 #define KRATOS_PURE_CONVECTION_CRANKN_UTILITIES_INCLUDED
14 
15 // System includes
16 #include <string>
17 #include <iostream>
18 #include <algorithm>
19 
20 // External includes
21 
22 // Project includes
23 #include "includes/define.h"
24 #include "includes/model_part.h"
25 #include "includes/node.h"
26 #include "utilities/geometry_utilities.h"
28 
29 namespace Kratos
30 {
31 
32 template<int TDim,class TSparseSpace,class TLinearSolver>
34 {
35 public:
36 
40 
41 
44 
45 
46 
47  //************************************************************************
48  //************************************************************************
50  {
52 
53  //loop over nodes with neighbours
54  mDofSet.clear(); // = DofsArrayType();
55  //mDofSet.resize(0);
56  mDofSet.reserve(model_part.Nodes().size() );
57 
58  int tot_nnz=0;
59  //int tot_row=0;
60  for (auto it=model_part.NodesBegin(); it!=model_part.NodesEnd(); ++it)
61  {
62  if( (it->GetValue(NEIGHBOUR_NODES)).size() != 0 )
63  {
64  mDofSet.push_back( it->pGetDof(rScalarVar) );
65  //tot_row += 1;
66  tot_nnz += (it->GetValue(NEIGHBOUR_NODES)).size()+1;
67  }
68  }
69 
70  //fills the DofList and give a unique progressive tag to each node
71 
72  int free_id = 0;
73  int fix_id = mDofSet.size();
74 
75  for (typename DofsArrayType::iterator dof_iterator = mDofSet.begin(); dof_iterator != mDofSet.end(); ++dof_iterator)
76  if (dof_iterator->IsFixed())
77  dof_iterator->SetEquationId(--fix_id);
78  else
79  dof_iterator->SetEquationId(free_id++);
80 
81  mEquationSystemSize = fix_id;
82 
83  std::vector< int > work_array;
84  work_array.reserve(1000);
85 
86  //guessing the total size of the matrix
87  mA.resize(mEquationSystemSize, mEquationSystemSize, tot_nnz);
88 
89  //getting the dof position
90  //unsigned int dof_position = (model_part.NodesBegin())->GetDofPosition(rScalarVar);
91 
92  //building up the matrix graph row by row
93  //int total_size = 0;
94  for (auto it=model_part.NodesBegin(); it!=model_part.NodesEnd(); ++it)
95  {
96  unsigned int index_i = it->GetDof(rScalarVar).EquationId();
97 
98  if(index_i < mEquationSystemSize && (it->GetValue(NEIGHBOUR_NODES)).size() != 0)
99  {
100  GlobalPointersVector< Node >& neighb_nodes = it->GetValue(NEIGHBOUR_NODES);
101 
102  //filling the first neighbours list
103  work_array.push_back(index_i);
104  for( GlobalPointersVector< Node >::iterator i = neighb_nodes.begin(); i != neighb_nodes.end(); i++)
105  {
106  unsigned int index_j = i->GetDof(rScalarVar).EquationId();
107  if(index_j < mEquationSystemSize)
108  work_array.push_back(index_j);
109  }
110 
111  //sorting the indices and elminating the duplicates
112  std::sort(work_array.begin(),work_array.end());
113  typename std::vector<int>::iterator new_end = std::unique(work_array.begin(),work_array.end());
114  unsigned int number_of_entries = new_end - work_array.begin();
115 
116  //filling up the matrix
117  for(unsigned int j=0; j<number_of_entries; j++)
118  {
119  mA.push_back(index_i,work_array[j] , 0.00);
120  }
121 
122  //clearing the array for the next step
123  work_array.erase(work_array.begin(),work_array.end());
124  //total_size += number_of_entries;
125  }
126 
127  }
128 
129  mDx.resize(mA.size1(),false);
130  mb.resize(mA.size1(),false);
131  KRATOS_CATCH("")
132  }
133 
134  //************************************************************************
135  //************************************************************************
137  typename TLinearSolver::Pointer linear_solver,
138  Variable<double>& rScalarVar,
139  const Variable< array_1d<double,3> >& rTransportVel,
140  const Variable< array_1d<double,3> >& rMeshVel,
141  const Variable< double >& rProjVar,
142  unsigned int time_order )
143  {
144  KRATOS_TRY
145 
146  TSparseSpace::SetToZero(mA);
147  TSparseSpace::SetToZero(mb);
148  TSparseSpace::SetToZero(mDx);
149 
150  ProcessInfo& CurrentProcessInfo = model_part.GetProcessInfo();
151  double dt = CurrentProcessInfo[DELTA_TIME];
152 
153  Vector BDFcoeffs(2);
154  /*
155  if(model_part.GetBufferSize() < 3)
156  KRATOS_THROW_ERROR(std::logic_error,"insufficient buffer size for BDF2","")*/
157 
158  BDFcoeffs[0] = 1.0 / dt; //coefficient for step n+1
159  BDFcoeffs[1] = -1.0 / dt; //coefficient for step n
160 
161  //check if divided
162 
163  KRATOS_WATCH("CONVECTION: CrankNicholson.......................................................................................");
164 
165  //**********************************
166  //BUILD PHASE
167  //**********************************
169  BoundedMatrix<double,TDim+1,TDim+1> lhs_contribution;
171  array_1d<unsigned int ,TDim+1> local_indices;
172  array_1d<double,TDim+1> rhs_contribution;
173  array_1d<double,TDim+1> dp_vector;
174  array_1d<double,TDim+1> MassFactors;
175  array_1d<double,TDim> vel_gauss;
176  array_1d<double,TDim> vel_gauss_old;
179  array_1d<double,TDim+1> temp_vec_np;
180 
181 
182 
183  for(unsigned int i=0; i<TDim+1; i++)
184  MassFactors[i] = 1.0/double(TDim+1);
185 
186  //getting the dof position
187 // unsigned int dof_position = (model_part.NodesBegin())->GetDofPosition(rScalarVar);
188 
189  double lumping_factor = 1.0/double(TDim+1.0);
190  const unsigned int number_of_points = TDim+1;
191 
193  for(ModelPart::ElementsContainerType::iterator i = model_part.ElementsBegin();
194  i!=model_part.ElementsEnd(); i++)
195  {
196  Geometry< Node >& geom = i->GetGeometry();
197 
198  //calculating elemental values
199  double Volume;
200  GeometryUtils::CalculateGeometryData(geom, DN_DX, N, Volume);
201 
202  //finiding local indices
203  for(int ii = 0; ii<TDim+1; ii++)
204  {
205  local_indices[ii] = geom[ii].GetDof(rScalarVar).EquationId();
206 
207  /* dp_vector[ii] = geom[ii].FastGetSolutionStepValue(rScalarVar)
208  - geom[ii].FastGetSolutionStepValue(rScalarVar,1);*/
209  }
210 
211  //calculating convective velocity
212  noalias(vel_gauss) = ZeroVector(TDim);
213  noalias(vel_gauss_old) = ZeroVector(TDim);
214  double proj = 0.0;
215  double proj_old = 0.0;
216  for(unsigned int i = 0; i<number_of_points; i++)
217  {
218  const array_1d<double,3>& v = geom[i].FastGetSolutionStepValue(rTransportVel);
219  const array_1d<double,3>& w = geom[i].FastGetSolutionStepValue(rMeshVel);
220  const array_1d<double,3>& v_old = geom[i].FastGetSolutionStepValue(rTransportVel,1);
221  const array_1d<double,3>& w_old = geom[i].FastGetSolutionStepValue(rMeshVel,1);
222  proj += geom[i].FastGetSolutionStepValue(rProjVar);
223  proj_old += geom[i].FastGetSolutionStepValue(rProjVar,1);
224  for(unsigned int j = 0; j<TDim; j++)
225  {
226  vel_gauss[j] += v[j] - w[j];
227  vel_gauss_old[j] += v_old[j] - w_old[j];
228  }
229  }
230  //change of meaning of vel_gauss; vel_gauss in n+1/2;
231  vel_gauss += vel_gauss_old;
232  vel_gauss *= lumping_factor*0.5;
233 
234  //change of meaning of proj: proj= proj_n+1/2;
235  proj += proj_old;
236  proj *= lumping_factor*0.5;
237 
238 
239 
240  //**********************************
241  //BUILD LHS
242  //**********************************
243  //CONVECTIVE CONTRIBUTION TO THE STIFFNESS MATRIX
244  noalias(u_DN) = prod(DN_DX , vel_gauss);
245  noalias(lhs_contribution) = 0.5*outer_prod(N,u_DN);
246 
247 
248  //CONVECTION STABILIZING CONTRIBUTION (Suu)
249  double tau = CalculateTAU(vel_gauss,Volume);
250  noalias(lhs_contribution) += 0.5*(tau) * outer_prod(u_DN,u_DN);
251 
252 
253 
254  //INERTIA CONTRIBUTION
255  for(unsigned int iii = 0; iii<number_of_points; iii++)
256  {
257  lhs_contribution(iii,iii) += BDFcoeffs[0] * MassFactors[iii];
258  }
259 
260  //**********************************
261  //BUILD RHS
262  //**********************************
263  //adding projection contribution
264  //RHS += Suy * proj[component]
265  noalias(rhs_contribution) = (tau*proj)*u_DN;
266 
267 
268  //adding the inertia terms
269  // RHS += M*vhistory
270  //calculating the historical velocity (rScalarVar,1 = vel previous step)
271  for(unsigned int iii = 0; iii<number_of_points; iii++)
272  {
273  temp_vec_np[iii] = BDFcoeffs[1]*geom[iii].FastGetSolutionStepValue(rScalarVar,1);
274  }
275 
276  for(unsigned int iii = 0; iii<number_of_points; iii++)
277  rhs_contribution[iii] -= MassFactors[iii]*temp_vec_np[iii];
278 
279 
280 
281  //subtracting the dirichlet term
282  // RHS -= LHS*rScalarVars ****RHS -= LHS*(v_n+1-v_n) (0.5 already included in lhs)
283  for(unsigned int iii = 0; iii<number_of_points; iii++)
284  {
285  temp_vec_np[iii] = geom[iii].FastGetSolutionStepValue(rScalarVar)+geom[iii].FastGetSolutionStepValue(rScalarVar,1);
286  }
287  noalias(rhs_contribution) -= prod(lhs_contribution,temp_vec_np);
288 
289 
290  //there is a part of the lhs which is already included.
291  for(unsigned int iii = 0; iii<number_of_points; iii++)
292  {
293  rhs_contribution[iii] += MassFactors[iii]*BDFcoeffs[0]*geom[iii].FastGetSolutionStepValue(rScalarVar,1);
294  }
295 
296 
297 
298 
299 
300 // KRATOS_WATCH(rhs_contribution);
301  //multiplying by Volume, rho and density
302  rhs_contribution *= Volume;
303  lhs_contribution *= Volume;
304 
305  AssembleLHS(mA,lhs_contribution,local_indices);
306  AssembleRHS(mb,rhs_contribution,local_indices);
307 
308 
309 
310  }
311 
312  //**********************************
313  //SOLVE PHASE
314  //**********************************
315 // KRATOS_WATCH(mA);
316 // KRATOS_WATCH(mb);
317 // KRATOS_WATCH(mDx);
318 // std::cout << "convection residual norm" << TSparseSpace::TwoNorm(mb) << std::endl;
319 
320  linear_solver->Solve(mA,mDx,mb);
321  std::cout << *(linear_solver) << std::endl;
322 // KRATOS_WATCH(mDx);
323 
324  //**********************************
325  //UPDATE rScalarVarS
326  //**********************************
327  for(typename DofsArrayType::iterator i_dof = mDofSet.begin() ; i_dof != mDofSet.end() ; ++i_dof)
328  {
329  if(i_dof->IsFree())
330  {
331  i_dof->GetSolutionStepValue() += mDx[i_dof->EquationId()];
332  }
333  }
334 
335  KRATOS_CATCH("")
336  }
337 
338 
339 
340 
341 
342  //************************************************************************
343  //************************************************************************
345  const Variable<double>& rScalarVar,
346  const Variable<double>& rNodalArea,
347  const Variable< array_1d<double,3> >& rTransportVel,
348  const Variable< array_1d<double,3> >& rMeshVel,
349  Variable< double >& rProjVar )
350  {
351  KRATOS_TRY
352 
353 
354  //**********************************
355  //BUILD PHASE
356  //**********************************
359  array_1d<double,TDim> vel_gauss;
360  array_1d<double,TDim+1> temp_vec_np;
362 
363  double lumping_factor = 1.0/double(TDim+1.0);
364  const unsigned int number_of_points = TDim+1;
365 
366  //set to zero nodal areas
367  for(ModelPart::NodesContainerType::iterator i = model_part.NodesBegin();
368  i!=model_part.NodesEnd(); i++)
369  {
370  i->FastGetSolutionStepValue(rNodalArea) = 0.0;
371  i->FastGetSolutionStepValue(rProjVar) = 0.0;
372  }
373 
374  //build up nodal areas and projections
376  for(ModelPart::ElementsContainerType::iterator i = model_part.ElementsBegin();
377  i!=model_part.ElementsEnd(); i++)
378  {
379 
380  Geometry< Node >& geom = i->GetGeometry();
381 
382  //calculating elemental values
383  double Volume;
384  GeometryUtils::CalculateGeometryData(geom, DN_DX, N, Volume);
385 
386  //calculating convective velocity
387  double nodal_area = Volume*lumping_factor;
388  noalias(vel_gauss) = ZeroVector(TDim);
389  for(unsigned int i = 0; i<number_of_points; i++)
390  {
391  const array_1d<double,3>& v = geom[i].FastGetSolutionStepValue(rTransportVel);
392  const array_1d<double,3>& w = geom[i].FastGetSolutionStepValue(rMeshVel);
393 
394  //adding up nodal area as needed
395  geom[i].FastGetSolutionStepValue(rNodalArea) += nodal_area;
396 
397  for(unsigned int j = 0; j<TDim; j++)
398  {
399  vel_gauss[j] += v[j] - w[j];
400  }
401  }
402  vel_gauss *= lumping_factor;
403 
404  //filling up a vector with all of the nodal values
405  for(unsigned int iii = 0; iii<number_of_points; iii++)
406  temp_vec_np[iii] = geom[iii].FastGetSolutionStepValue(rScalarVar);
407 
408  //
409  noalias(u_DN) = prod(DN_DX , vel_gauss);
410  double conv_proj = inner_prod( u_DN , temp_vec_np);
411  conv_proj *= Volume * lumping_factor;
412 
413  for(unsigned int iii = 0; iii<number_of_points; iii++)
414  geom[iii].FastGetSolutionStepValue(rProjVar) += conv_proj;
415  }
416 
417  //dividing by the overall mass matrix
418  for(ModelPart::NodesContainerType::iterator i = model_part.NodesBegin();
419  i!=model_part.NodesEnd(); i++)
420  {
421  i->FastGetSolutionStepValue(rProjVar) /= i->FastGetSolutionStepValue(rNodalArea);
422  }
423 
424  KRATOS_CATCH("")
425  }
426 
427  void ClearSystem()
428  {
429  KRATOS_TRY
430  mDofSet.clear(); // = DofsArrayType();
431  // mDofSet.resize(0);
432  mDx.resize(0,false);
433  mb.resize(0,false);
434  mA.resize(0,0,false);
435 
436  KRATOS_CATCH("")
437  }
438 
439 
440 
441 
442 private:
443 
444  unsigned int mEquationSystemSize;
445  TSystemVectorType mDx;
448  DofsArrayType mDofSet;
449 
450 
451 
452 
453 
454  //**************************************************************************
455  void AssembleLHS(
457  const BoundedMatrix<double,TDim+1,TDim+1>& LHS_Contribution,
458  const array_1d<unsigned int,TDim+1>& EquationId
459  )
460  {
461  unsigned int local_size = LHS_Contribution.size1();
462 
463  for (unsigned int i_local=0; i_local<local_size; i_local++)
464  {
465  unsigned int i_global=EquationId[i_local];
466  if ( i_global < mEquationSystemSize )
467  {
468  for (unsigned int j_local=0; j_local<local_size; j_local++)
469  {
470  unsigned int j_global=EquationId[j_local];
471  if ( j_global < mEquationSystemSize )
472  A(i_global,j_global) += LHS_Contribution(i_local,j_local);
473  }
474  }
475  }
476  }
477 
478 
479 
480  //**************************************************************************
481  void AssembleRHS(
483  const array_1d<double,TDim+1>& RHS_Contribution,
484  const array_1d<unsigned int,TDim+1>& EquationId
485  )
486  {
487  unsigned int local_size = RHS_Contribution.size();
488 
489  for (unsigned int i_local=0; i_local<local_size; i_local++)
490  {
491  unsigned int i_global=EquationId[i_local];
492  if ( i_global < mEquationSystemSize ) //on "free" DOFs
493  {
494  // ASSEMBLING THE SYSTEM VECTOR
495  b[i_global] += RHS_Contribution[i_local];
496  }
497  }
498 
499  }
500 
501  double CalculateTAU(const array_1d<double,2>& vel, const double& Volume)
502  {
503  //calculating parameter tau
504 // double c1 = 4.00;
505  double c2 = 2.00;
506  double h = sqrt(2.00*Volume);
507  double norm_u =norm_2(vel);
508  if(norm_u > 1e-15)
509  return h / ( c2*norm_u );
510  return 0.0;
511  }
512 
513  double CalculateTAU(const array_1d<double,3>& vel, const double& Volume)
514  {
515  //calculating parameter tau
516 // double c1 = 4.00;
517  double c2 = 2.00;
518  double h = pow(6.00*Volume,0.3333333);
519  double norm_u =norm_2(vel);
520  if(norm_u > 1e-15)
521  return h / ( c2*norm_u );
522  return 0.0;
523  }
524 
525 };
526 
527 } // namespace Kratos.
528 
529 #endif // KRATOS_PURE_CONVECTION_CRANKN_UTILITIES_INCLUDED defined
Geometry base class.
Definition: geometry.h:71
static void CalculateGeometryData(const GeometryType &rGeometry, BoundedMatrix< double, 4, 3 > &rDN_DX, array_1d< double, 4 > &rN, double &rVolume)
This function is designed to compute the shape function derivatives, shape functions and volume in 3D...
Definition: geometry_utilities.h:176
This class is a vector which stores global pointers.
Definition: global_pointers_vector.h:61
boost::indirect_iterator< typename TContainerType::iterator > iterator
Definition: global_pointers_vector.h:79
void push_back(TPointerType x)
Definition: global_pointers_vector.h:322
iterator begin()
Definition: global_pointers_vector.h:221
iterator end()
Definition: global_pointers_vector.h:229
This object defines an indexed object.
Definition: indexed_object.h:54
This class aims to manage meshes for multi-physics simulations.
Definition: model_part.h:77
A sorted associative container similar to an STL set, but uses a vector to store pointers to its data...
Definition: pointer_vector_set.h:72
void clear()
Clear the set, removing all elements.
Definition: pointer_vector_set.h:663
boost::indirect_iterator< typename TContainerType::iterator > iterator
Definition: pointer_vector_set.h:95
size_type size() const
Returns the number of elements in the container.
Definition: pointer_vector_set.h:502
void push_back(TPointerType x)
Adds a pointer to the end of the set.
Definition: pointer_vector_set.h:544
iterator begin()
Returns an iterator pointing to the beginning of the container.
Definition: pointer_vector_set.h:278
void reserve(int reservedsize)
Reserves memory for a specified number of elements.
Definition: pointer_vector_set.h:733
iterator end()
Returns an iterator pointing to the end of the container.
Definition: pointer_vector_set.h:314
ProcessInfo holds the current value of different solution parameters.
Definition: process_info.h:59
Definition: pure_convection_CrankN_tools.h:34
PointerVectorSet< Dof< double >, IndexedObject > DofsArrayType
Definition: pure_convection_CrankN_tools.h:39
TSparseSpace::MatrixType TSystemMatrixType
Definition: pure_convection_CrankN_tools.h:37
void ConvectScalarVar(ModelPart &model_part, typename TLinearSolver::Pointer linear_solver, Variable< double > &rScalarVar, const Variable< array_1d< double, 3 > > &rTransportVel, const Variable< array_1d< double, 3 > > &rMeshVel, const Variable< double > &rProjVar, unsigned int time_order)
Definition: pure_convection_CrankN_tools.h:136
TSparseSpace::VectorType TSystemVectorType
Definition: pure_convection_CrankN_tools.h:38
void CalculateProjection(ModelPart &model_part, const Variable< double > &rScalarVar, const Variable< double > &rNodalArea, const Variable< array_1d< double, 3 > > &rTransportVel, const Variable< array_1d< double, 3 > > &rMeshVel, Variable< double > &rProjVar)
Definition: pure_convection_CrankN_tools.h:344
void ConstructSystem(ModelPart &model_part, Variable< double > &rScalarVar, Variable< array_1d< double, 3 > > &rTransportVel, Variable< array_1d< double, 3 > > &rMeshVel)
Definition: pure_convection_CrankN_tools.h:49
void ClearSystem()
Definition: pure_convection_CrankN_tools.h:427
~PureConvectionCrankNUtilities()
Definition: pure_convection_CrankN_tools.h:43
PureConvectionCrankNUtilities()
Definition: pure_convection_CrankN_tools.h:42
#define KRATOS_CATCH(MoreInfo)
Definition: define.h:110
#define KRATOS_WATCH(variable)
Definition: define.h:806
#define KRATOS_TRY
Definition: define.h:109
dt
Definition: DEM_benchmarks.py:173
Vector VectorType
Definition: geometrical_transformation_utilities.h:56
Matrix MatrixType
Definition: geometrical_transformation_utilities.h:55
REF: G. R. Cowper, GAUSSIAN QUADRATURE FORMULAS FOR TRIANGLES.
Definition: mesh_condition.cpp:21
KratosZeroVector< double > ZeroVector
Definition: amatrix_interface.h:561
TExpressionType::data_type norm_2(AMatrix::MatrixExpression< TExpressionType, TCategory > const &TheExpression)
Definition: amatrix_interface.h:625
AMatrix::MatrixProductExpression< TExpression1Type, TExpression2Type > prod(AMatrix::MatrixExpression< TExpression1Type, TCategory1 > const &First, AMatrix::MatrixExpression< TExpression2Type, TCategory2 > const &Second)
Definition: amatrix_interface.h:568
TExpression1Type::data_type inner_prod(AMatrix::MatrixExpression< TExpression1Type, TCategory1 > const &First, AMatrix::MatrixExpression< TExpression2Type, TCategory2 > const &Second)
Definition: amatrix_interface.h:592
AMatrix::VectorOuterProductExpression< TExpression1Type, TExpression2Type > outer_prod(AMatrix::MatrixExpression< TExpression1Type, TCategory1 > const &First, AMatrix::MatrixExpression< TExpression2Type, TCategory2 > const &Second)
Definition: amatrix_interface.h:582
T & noalias(T &TheMatrix)
Definition: amatrix_interface.h:484
TABLE_NUMBER_ANGULAR_VELOCITY TABLE_NUMBER_MOMENT I33 BEAM_INERTIA_ROT_UNIT_LENGHT_Y KRATOS_DEFINE_APPLICATION_VARIABLE(DEM_APPLICATION, double, BEAM_INERTIA_ROT_UNIT_LENGHT_Z) typedef std double
Definition: DEM_application_variables.h:182
int time_order
Definition: ProjectParameters.py:51
model_part
Definition: face_heat.py:14
v
Definition: generate_convection_diffusion_explicit_element.py:114
w
Definition: generate_convection_diffusion_explicit_element.py:108
tau
Definition: generate_convection_diffusion_explicit_element.py:115
h
Definition: generate_droplet_dynamics.py:91
int local_size
Definition: generate_total_lagrangian_mixed_volumetric_strain_element.py:17
b
Definition: generate_total_lagrangian_mixed_volumetric_strain_element.py:31
vel
Definition: pure_conduction.py:76
int j
Definition: quadrature.py:648
A
Definition: sensitivityMatrix.py:70
N
Definition: sensitivityMatrix.py:29
integer i
Definition: TensorModule.f:17
e
Definition: run_cpp_mpi_tests.py:31