Dear Thomas, I found the problem. Your version works exactly like discussed in your paper, even faster with my Intel i7, namely around 1400 s. The timeconsuming part is the computation of my B-operator.
The B-operator computation is implemented inside* assemble_system (bool residual_only):* for (; cell != endc; ++cell) if ( cell->is_locally_owned() ) { fe_values.reinit(cell); local_matrix = 0; local_rhs = 0; int cell_index = cell->active_cell_index(); ... // COMPUTE: B-Operator for (unsigned int q = 0; q < n_q_points; ++q) // loop over integration/quadrature points (GPs) { b_operators[cell_index][q] = Tensors::*get_b_operator*(fe_values, dofs_per_cell, q); } *B* = b_operators; // Old Newton iteration values fe_values.get_function_values(rel_solution, old_solution_values); fe_values.get_function_gradients(rel_solution, old_solution_grads); ... } The variable *B *is a history variable I created to store the B-operator history and has been initialized in the main class function according to: std::vector<std::vector<FullMatrix<double>>>B; // temporary cell storage solution (inefficient!) The function *get_b_operator()* which is called within the Gauss points loop is implemented in Tensors: template<int dim> FullMatrix<double> get_b_operator (const FEValues<dim> &fe_values, const unsigned int dofs_per_cell, const unsigned int q) { FullMatrix<double> tmp(dim, GeometryInfo<dim>::vertices_per_cell); // Remark: For vector-valued problems each column is a value for each value of the solution variable, hence here 3 DoFs per node (dofs_per_cell = 12)! for (unsigned int i = 0; i < dofs_per_cell; i += 3) { const unsigned int index = i / 3; // COMPUTE: B-operator (Remark: This version has to be extended for 3D!) tmp[0][index] = fe_values.shape_grad_component(i, q, 0)[0]; tmp[1][index] = fe_values.shape_grad_component(i, q, 0)[1]; } return tmp; } I assume (as I already wrote within my comments inside the above code) that this kind of cell storage for matrices turns out to be quite slow and inefficient. Jean-Paul offered me once to use the new CellDataStorage function, if I remember correctly. Isn't there a nice and elegant way to store data in each Gauss point and cell without loss of computational time? Or am I able to pass the B-operator to another function somehow after I have solved the system? Something similar to your predictor-corrector scheme. It seems you somehow pass data more efficiently from one function to another function even after you solved the system. Do you also pass cell data from a function before solving to a function after solving? Best, Seyed Ali -- The deal.II project is located at http://www.dealii.org/ For mailing list/forum options, see https://groups.google.com/d/forum/dealii?hl=en --- You received this message because you are subscribed to the Google Groups "deal.II User Group" group. To unsubscribe from this group and stop receiving emails from it, send an email to dealii+unsubscr...@googlegroups.com. For more options, visit https://groups.google.com/d/optout.