/** * This function assemble the stiffnes matrix KK and the residual vector Res * Using automatic differentiation for Newton iterative scheme * J(u0) w = - F(u0) , * with u = u0 + w * - F = f(x) - J u = Res * J = \grad_u F * * thus * J w = f(x) - J u0 **/ void AssemblePoissonProblem_AD(MultiLevelProblem& ml_prob) { // ml_prob is the global object from/to where get/set all the data // level is the level of the PDE system to be assembled // levelMax is the Maximum level of the MultiLevelProblem // assembleMatrix is a flag that tells if only the residual or also the matrix should be assembled // call the adept stack object adept::Stack& s = FemusInit::_adeptStack; // extract pointers to the several objects that we are going to use LinearImplicitSystem* mlPdeSys = &ml_prob.get_system<LinearImplicitSystem> ("Poisson"); // pointer to the linear implicit system named "Poisson" const unsigned level = mlPdeSys->GetLevelToAssemble(); Mesh* msh = ml_prob._ml_msh->GetLevel(level); // pointer to the mesh (level) object elem* el = msh->el; // pointer to the elem object in msh (level) MultiLevelSolution* mlSol = ml_prob._ml_sol; // pointer to the multilevel solution object Solution* sol = ml_prob._ml_sol->GetSolutionLevel(level); // pointer to the solution (level) object LinearEquationSolver* pdeSys = mlPdeSys->_LinSolver[level]; // pointer to the equation (level) object SparseMatrix* KK = pdeSys->_KK; // pointer to the global stifness matrix object in pdeSys (level) NumericVector* RES = pdeSys->_RES; // pointer to the global residual vector object in pdeSys (level) const unsigned dim = msh->GetDimension(); // get the domain dimension of the problem unsigned dim2 = (3 * (dim - 1) + !(dim - 1)); // dim2 is the number of second order partial derivatives (1,3,6 depending on the dimension) const unsigned maxSize = static_cast< unsigned >(ceil(pow(3, dim))); // conservative: based on line3, quad9, hex27 unsigned iproc = msh->processor_id(); // get the process_id (for parallel computation) //solution variable unsigned soluIndex; soluIndex = mlSol->GetIndex("u"); // get the position of "u" in the ml_sol object unsigned soluType = mlSol->GetSolutionType(soluIndex); // get the finite element type for "u" unsigned soluPdeIndex; soluPdeIndex = mlPdeSys->GetSolPdeIndex("u"); // get the position of "u" in the pdeSys object vector < adept::adouble > solu; // local solution solu.reserve(maxSize); vector < vector < double > > x(dim); // local coordinates unsigned xType = 2; // get the finite element type for "x", it is always 2 (LAGRANGE QUADRATIC) for (unsigned i = 0; i < dim; i++) { x[i].reserve(maxSize); } vector <double> phi; // local test function vector <double> phi_x; // local test function first order partial derivatives vector <double> phi_xx; // local test function second order partial derivatives double weight; // gauss point weight phi.reserve(maxSize); phi_x.reserve(maxSize * dim); phi_xx.reserve(maxSize * dim2); vector< adept::adouble > aRes; // local redidual vector aRes.reserve(maxSize); vector< int > l2GMap; // local to global mapping l2GMap.reserve(maxSize); vector< double > Res; // local redidual vector Res.reserve(maxSize); vector < double > Jac; Jac.reserve(maxSize * maxSize); KK->zero(); // Set to zero all the entries of the Global Matrix // element loop: each process loops only on the elements that owns for (int iel = msh->_elementOffset[iproc]; iel < msh->_elementOffset[iproc + 1]; iel++) { short unsigned ielGeom = msh->GetElementType(iel); unsigned nDofu = msh->GetElementDofNumber(iel, soluType); // number of solution element dofs unsigned nDofx = msh->GetElementDofNumber(iel, xType); // number of coordinate element dofs // resize local arrays l2GMap.resize(nDofu); solu.resize(nDofu); for (int i = 0; i < dim; i++) { x[i].resize(nDofx); } aRes.resize(nDofu); //resize std::fill(aRes.begin(), aRes.end(), 0); //set aRes to zero // local storage of global mapping and solution for (unsigned i = 0; i < nDofu; i++) { unsigned solDof = msh->GetSolutionDof(i, iel, soluType); // global to global mapping between solution node and solution dof solu[i] = (*sol->_Sol[soluIndex])(solDof); // global extraction and local storage for the solution l2GMap[i] = pdeSys->GetSystemDof(soluIndex, soluPdeIndex, i, iel); // global to global mapping between solution node and pdeSys dof } // local storage of coordinates for (unsigned i = 0; i < nDofx; i++) { unsigned xDof = msh->GetSolutionDof(i, iel, xType); // global to global mapping between coordinates node and coordinate dof for (unsigned jdim = 0; jdim < dim; jdim++) { x[jdim][i] = (*msh->_topology->_Sol[jdim])(xDof); // global extraction and local storage for the element coordinates } } // start a new recording of all the operations involving adept::adouble variables s.new_recording(); // *** Gauss point loop *** for (unsigned ig = 0; ig < msh->_finiteElement[ielGeom][soluType]->GetGaussPointNumber(); ig++) { // *** get gauss point weight, test function and test function partial derivatives *** msh->_finiteElement[ielGeom][soluType]->Jacobian(x, ig, weight, phi, phi_x, phi_xx); // evaluate the solution, the solution derivatives and the coordinates in the gauss point adept::adouble solu_gss = 0; vector < adept::adouble > gradSolu_gss(dim, 0.); vector < double > x_gss(dim, 0.); for (unsigned i = 0; i < nDofu; i++) { solu_gss += phi[i] * solu[i]; for (unsigned jdim = 0; jdim < dim; jdim++) { gradSolu_gss[jdim] += phi_x[i * dim + jdim] * solu[i]; x_gss[jdim] += x[jdim][i] * phi[i]; } } // *** phi_i loop *** for (unsigned i = 0; i < nDofu; i++) { adept::adouble laplace = 0.; for (unsigned jdim = 0; jdim < dim; jdim++) { laplace += phi_x[i * dim + jdim] * gradSolu_gss[jdim]; } double srcTerm = - GetExactSolutionLaplace(x_gss); aRes[i] += (srcTerm * phi[i] - laplace) * weight; } // end phi_i loop } // end gauss point loop //-------------------------------------------------------------------------------------------------------- // Add the local Matrix/Vector into the global Matrix/Vector //copy the value of the adept::adoube aRes in double Res and store Res.resize(nDofu); //resize for (int i = 0; i < nDofu; i++) { Res[i] = - aRes[i].value(); } RES->add_vector_blocked(Res, l2GMap); // define the dependent variables s.dependent(&aRes[0], nDofu); // define the independent variables s.independent(&solu[0], nDofu); // get the jacobian matrix (ordered by row major ) Jac.resize(nDofu * nDofu); //resize s.jacobian(&Jac[0], true); //store K in the global matrix KK KK->add_matrix_blocked(Jac, l2GMap, l2GMap); s.clear_independents(); s.clear_dependents(); } //end element loop for each process RES->close(); KK->close(); // ***************** END ASSEMBLY ******************* }
void GetL2Norm ( MultiLevelProblem& ml_prob, MultiLevelProblem& ml_prob2 ) { LinearImplicitSystem* mlPdeSys = &ml_prob.get_system<LinearImplicitSystem> ( "NonLocal" ); const unsigned level = mlPdeSys->GetLevelToAssemble(); Mesh* msh = ml_prob._ml_msh->GetLevel ( level ); elem* el = msh->el; MultiLevelSolution* mlSol = ml_prob._ml_sol; Solution* sol = ml_prob._ml_sol->GetSolutionLevel ( level ); LinearImplicitSystem* mlPdeSys2 = &ml_prob2.get_system<LinearImplicitSystem> ( "Local" ); MultiLevelSolution* mlSol2 = ml_prob2._ml_sol; Solution* sol2 = ml_prob2._ml_sol->GetSolutionLevel ( level ); const unsigned dim = msh->GetDimension(); unsigned xType = 2; // get the finite element type for "x", it is always 2 (LAGRANGE QUADRATIC) double error_solExact_norm2 = 0.; double error_solExact_local_norm2 = 0.; double error_solLocal_norm2 = 0.; double solNonlocal_norm2 = 0.; double solLocal_norm2 = 0.; double sol_exact_norm2 = 0.; unsigned soluIndex; soluIndex = mlSol->GetIndex ( "u" ); unsigned soluType = mlSol->GetSolutionType ( soluIndex ); unsigned soluIndexLocal; soluIndexLocal = mlSol2->GetIndex ( "u_local" ); unsigned iproc = msh->processor_id(); unsigned nprocs = msh->n_processors(); for ( int iel = msh->_elementOffset[iproc]; iel < msh->_elementOffset[iproc + 1]; iel++ ) { short unsigned ielGeom = msh->GetElementType ( iel ); unsigned nDofu = msh->GetElementDofNumber ( iel, soluType ); unsigned nDofx = msh->GetElementDofNumber ( iel, xType ); vector < vector < double > > x1 ( dim ); for ( int i = 0; i < dim; i++ ) { x1[i].resize ( nDofx ); } vector < double > soluNonLoc ( nDofu ); vector < double > soluLoc ( nDofu ); for ( unsigned i = 0; i < nDofu; i++ ) { unsigned solDof = msh->GetSolutionDof ( i, iel, soluType ); soluNonLoc[i] = ( *sol->_Sol[soluIndex] ) ( solDof ); soluLoc[i] = ( *sol2->_Sol[soluIndexLocal] ) ( solDof ); } for ( unsigned i = 0; i < nDofx; i++ ) { unsigned xDof = msh->GetSolutionDof ( i, iel, xType ); for ( unsigned jdim = 0; jdim < dim; jdim++ ) { x1[jdim][i] = ( *msh->_topology->_Sol[jdim] ) ( xDof ); } } vector <double> phi; // local test function vector <double> phi_x; // local test function first order partial derivatives double weight; // gauss point weight // *** Gauss point loop *** for ( unsigned ig = 0; ig < msh->_finiteElement[ielGeom][soluType]->GetGaussPointNumber(); ig++ ) { // *** get gauss point weight, test function and test function partial derivatives *** msh->_finiteElement[ielGeom][soluType]->Jacobian ( x1, ig, weight, phi, phi_x ); double soluNonLoc_gss = 0.; double soluLoc_gss = 0.; double exactSol_gss_x = 0.; double exactSol_gss_y = 0.; for ( unsigned i = 0; i < nDofu; i++ ) { soluNonLoc_gss += phi[i] * soluNonLoc[i]; soluLoc_gss += phi[i] * soluLoc[i]; exactSol_gss_x += phi[i] * x1[0][i]; // this is x at the Gauss point // exactSol_gss_y += phi[i] * x1[1][i]; // this is y at the Gauss point } exactSol_gss_x = exactSol_gss_x * exactSol_gss_x * exactSol_gss_x * exactSol_gss_x + 0.1 * exactSol_gss_x * exactSol_gss_x; // this is x^4 + delta * x^2 // exactSol_gss_x = exactSol_gss_x * exactSol_gss_x; // this is x^2 // exactSol_gss_x = exactSol_gss_x * exactSol_gss_x * exactSol_gss_x; // this is x^3 // exactSol_gss_y = exactSol_gss_y * exactSol_gss_y * exactSol_gss_y; // this is y^3 // exactSol_gss_x = exactSol_gss_x * exactSol_gss_x * exactSol_gss_x * exactSol_gss_x; // this is x^4 // exactSol_gss_x = 2 * exactSol_gss_x + exactSol_gss_x * exactSol_gss_x * exactSol_gss_x * exactSol_gss_x * exactSol_gss_x ; // this is 2x + x^5 error_solExact_norm2 += ( soluNonLoc_gss - exactSol_gss_x ) * ( soluNonLoc_gss - exactSol_gss_x ) * weight; // error_solExact_norm2 += (soluNonLoc_gss - (exactSol_gss_x + exactSol_gss_y)) * (soluNonLoc_gss - (exactSol_gss_x + exactSol_gss_y)) * weight; //error L2 norm of x^3 + y^3 error_solExact_local_norm2 += ( soluLoc_gss - exactSol_gss_x ) * ( soluLoc_gss - exactSol_gss_x ) * weight; error_solLocal_norm2 += ( soluNonLoc_gss - soluLoc_gss ) * ( soluNonLoc_gss - soluLoc_gss ) * weight; solNonlocal_norm2 += soluNonLoc_gss * soluNonLoc_gss * weight; solLocal_norm2 += soluLoc_gss * soluLoc_gss * weight; // sol_exact_norm2 += (exactSol_gss_x + exactSol_gss_y) * (exactSol_gss_x + exactSol_gss_y) * weight; //L2 norm of x^3 + y^3 sol_exact_norm2 += exactSol_gss_x * exactSol_gss_x * weight; } } double norm2 = 0.; MPI_Allreduce ( &error_solExact_norm2, &norm2, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD ); double norm = sqrt ( norm2 ); std::cout.precision ( 14 ); std::cout << "L2 norm of ERROR: Nonlocal - exact = " << norm << std::endl; norm2 = 0.; MPI_Allreduce ( &error_solExact_local_norm2, &norm2, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD ); norm = sqrt ( norm2 ); std::cout.precision ( 14 ); std::cout << "L2 norm of ERROR: Local - exact = " << norm << std::endl; norm2 = 0.; MPI_Allreduce ( &error_solLocal_norm2, &norm2, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD ); norm = sqrt ( norm2 ); std::cout.precision ( 14 ); std::cout << "L2 norm of ERROR: Nonlocal - local = " << norm << std::endl; norm2 = 0.; MPI_Allreduce ( &solNonlocal_norm2, &norm2, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD ); norm = sqrt ( norm2 ); std::cout.precision ( 14 ); std::cout << "L2 norm of NONLOCAL soln = " << norm << std::endl; norm2 = 0.; MPI_Allreduce ( &solLocal_norm2, &norm2, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD ); norm = sqrt ( norm2 ); std::cout.precision ( 14 ); std::cout << "L2 norm of LOCAL soln = " << norm << std::endl; norm2 = 0.; MPI_Allreduce ( &sol_exact_norm2, &norm2, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD ); norm = sqrt ( norm2 ); std::cout.precision ( 14 ); std::cout << "L2 norm of EXACT soln = " << norm << std::endl; double littleL2norm = 0.; std::vector<double> littleLInfinitynorm ( nprocs, 0. ); for ( unsigned i = msh->_dofOffset[soluType][iproc]; i < msh->_dofOffset[soluType][iproc + 1]; i++ ) { double nonLocalNodalValue = ( *sol->_Sol[soluIndex] ) ( i ); double LocalNodalValue = ( *sol2->_Sol[soluIndexLocal] ) ( i ); double difference = fabs ( nonLocalNodalValue - LocalNodalValue ); if ( difference > littleLInfinitynorm[iproc] ) littleLInfinitynorm[iproc] = difference; littleL2norm += difference * difference; } norm2 = 0.; MPI_Allreduce ( &littleL2norm, &norm2, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD ); norm = sqrt ( norm2 ); std::cout.precision ( 14 ); std::cout << "l2 norm of ERROR: Nonlocal - local = " << norm << std::endl; for ( int kproc = 0; kproc < nprocs; kproc++ ) { MPI_Bcast ( &littleLInfinitynorm[iproc], 1, MPI_DOUBLE, kproc, MPI_COMM_WORLD ); } double littleLInfinityNorm = littleLInfinitynorm[0]; for ( unsigned kproc = 0; kproc < nprocs; kproc++ ) { if ( littleLInfinitynorm[kproc] > littleLInfinityNorm ) littleLInfinityNorm = littleLInfinitynorm[kproc]; } std::cout.precision ( 14 ); std::cout << "linfinity norm of ERROR: Nonlocal - local = " << littleLInfinityNorm << std::endl; }
/** * This function assemble the stiffnes matrix Jac and the residual vector Res * such that * Jac w = RES = F - Jac u0, * and consequently * u = u0 + w satisfies Jac u = F **/ void AssemblePoissonProblem(MultiLevelProblem& ml_prob) { // ml_prob is the global object from/to where get/set all the data // level is the level of the PDE system to be assembled // levelMax is the Maximum level of the MultiLevelProblem // assembleMatrix is a flag that tells if only the residual or also the matrix should be assembled // extract pointers to the several objects that we are going to use LinearImplicitSystem* mlPdeSys = &ml_prob.get_system<LinearImplicitSystem> ("Poisson"); // pointer to the linear implicit system named "Poisson" const unsigned level = mlPdeSys->GetLevelToAssemble(); const unsigned levelMax = mlPdeSys->GetLevelMax(); const bool assembleMatrix = mlPdeSys->GetAssembleMatrix(); Mesh* msh = ml_prob._ml_msh->GetLevel(level); // pointer to the mesh (level) object elem* el = msh->el; // pointer to the elem object in msh (level) MultiLevelSolution* mlSol = ml_prob._ml_sol; // pointer to the multilevel solution object Solution* sol = ml_prob._ml_sol->GetSolutionLevel(level); // pointer to the solution (level) object LinearEquationSolver* pdeSys = mlPdeSys->_LinSolver[level]; // pointer to the equation (level) object SparseMatrix* KK = pdeSys->_KK; // pointer to the global stifness matrix object in pdeSys (level) NumericVector* RES = pdeSys->_RES; // pointer to the global residual vector object in pdeSys (level) const unsigned dim = msh->GetDimension(); // get the domain dimension of the problem unsigned dim2 = (3 * (dim - 1) + !(dim - 1)); // dim2 is the number of second order partial derivatives (1,3,6 depending on the dimension) const unsigned maxSize = static_cast< unsigned >(ceil(pow(3, dim))); // conservative: based on line3, quad9, hex27 unsigned iproc = msh->processor_id(); // get the process_id (for parallel computation) //solution variable unsigned soluIndex; soluIndex = mlSol->GetIndex("u"); // get the position of "u" in the ml_sol object unsigned soluType = mlSol->GetSolutionType(soluIndex); // get the finite element type for "u" unsigned soluPdeIndex; soluPdeIndex = mlPdeSys->GetSolPdeIndex("u"); // get the position of "u" in the pdeSys object vector < double > solu; // local solution solu.reserve(maxSize); vector < vector < double > > x(dim); // local coordinates unsigned xType = 2; // get the finite element type for "x", it is always 2 (LAGRANGE QUADRATIC) for (unsigned i = 0; i < dim; i++) { x[i].reserve(maxSize); } vector <double> phi; // local test function vector <double> phi_x; // local test function first order partial derivatives vector <double> phi_xx; // local test function second order partial derivatives double weight; // gauss point weight phi.reserve(maxSize); phi_x.reserve(maxSize * dim); phi_xx.reserve(maxSize * dim2); vector< double > Res; // local redidual vector Res.reserve(maxSize); vector< int > l2GMap; // local to global mapping l2GMap.reserve(maxSize); vector < double > Jac; Jac.reserve(maxSize * maxSize); if (assembleMatrix) KK->zero(); // Set to zero all the entries of the Global Matrix // element loop: each process loops only on the elements that owns for (int iel = msh->IS_Mts2Gmt_elem_offset[iproc]; iel < msh->IS_Mts2Gmt_elem_offset[iproc + 1]; iel++) { unsigned kel = msh->IS_Mts2Gmt_elem[iel]; // mapping between paralell dof and mesh dof short unsigned kelGeom = el->GetElementType(kel); // element geometry type unsigned nDofu = el->GetElementDofNumber(kel, soluType); // number of solution element dofs unsigned nDofx = el->GetElementDofNumber(kel, xType); // number of coordinate element dofs // resize local arrays l2GMap.resize(nDofu); solu.resize(nDofu); for (int i = 0; i < dim; i++) { x[i].resize(nDofx); } Res.resize(nDofu); //resize std::fill(Res.begin(), Res.end(), 0); //set Res to zero Jac.resize(nDofu * nDofu); //resize std::fill(Jac.begin(), Jac.end(), 0); //set Jac to zero // local storage of global mapping and solution for (unsigned i = 0; i < nDofu; i++) { unsigned iNode = el->GetMeshDof(kel, i, soluType); // local to global solution node unsigned solDof = msh->GetMetisDof(iNode, soluType); // global to global mapping between solution node and solution dof solu[i] = (*sol->_Sol[soluIndex])(solDof); // global extraction and local storage for the solution l2GMap[i] = pdeSys->GetKKDof(soluIndex, soluPdeIndex, iNode); // global to global mapping between solution node and pdeSys dof } // local storage of coordinates for (unsigned i = 0; i < nDofx; i++) { unsigned iNode = el->GetMeshDof(kel, i, xType); // local to global coordinates node unsigned xDof = msh->GetMetisDof(iNode, xType); // global to global mapping between coordinates node and coordinate dof for (unsigned jdim = 0; jdim < dim; jdim++) { x[jdim][i] = (*msh->_coordinate->_Sol[jdim])(xDof); // global extraction and local storage for the element coordinates } } if (level == levelMax || !el->GetRefinedElementIndex(kel)) { // do not care about this if now (it is used for the AMR) // *** Gauss point loop *** for (unsigned ig = 0; ig < msh->_finiteElement[kelGeom][soluType]->GetGaussPointNumber(); ig++) { // *** get gauss point weight, test function and test function partial derivatives *** msh->_finiteElement[kelGeom][soluType]->Jacobian(x, ig, weight, phi, phi_x, phi_xx); // evaluate the solution, the solution derivatives and the coordinates in the gauss point double solu_gss = 0; vector < double > gradSolu_gss(dim, 0.); vector < double > x_gss(dim, 0.); for (unsigned i = 0; i < nDofu; i++) { solu_gss += phi[i] * solu[i]; for (unsigned jdim = 0; jdim < dim; jdim++) { gradSolu_gss[jdim] += phi_x[i * dim + jdim] * solu[i]; x_gss[jdim] += x[jdim][i] * phi[i]; } } // *** phi_i loop *** for (unsigned i = 0; i < nDofu; i++) { double laplace = 0.; for (unsigned jdim = 0; jdim < dim; jdim++) { laplace += phi_x[i * dim + jdim] * gradSolu_gss[jdim]; } double srcTerm = - GetExactSolutionLaplace(x_gss); Res[i] += (srcTerm * phi[i] - laplace) * weight; if (assembleMatrix) { // *** phi_j loop *** for (unsigned j = 0; j < nDofu; j++) { laplace = 0.; for (unsigned kdim = 0; kdim < dim; kdim++) { laplace += (phi_x[i * dim + kdim] * phi_x[j * dim + kdim]) * weight; } Jac[i * nDofu + j] += laplace; } // end phi_j loop } // endif assemble_matrix } // end phi_i loop } // end gauss point loop } // endif single element not refined or fine grid loop //-------------------------------------------------------------------------------------------------------- // Add the local Matrix/Vector into the global Matrix/Vector //copy the value of the adept::adoube aRes in double Res and store RES->add_vector_blocked(Res, l2GMap); if (assembleMatrix) { //store K in the global matrix KK KK->add_matrix_blocked(Jac, l2GMap, l2GMap); } } //end element loop for each process RES->close(); if (assembleMatrix) KK->close(); // ***************** END ASSEMBLY ******************* }