void DrivenCavity<Dim>::Jacobian(const vector_ptrtype& X, sparse_matrix_ptrtype& J) { auto U = Vh->element( "(u,p)" ); auto V = Vh->element( "(v,q)" ); auto u = U.template element<0>( "u" ); auto v = V.template element<0>( "u" ); auto p = U.template element<1>( "p" ); auto q = V.template element<1>( "p" ); //#if defined( FEELPP_USE_LM ) auto lambda = U.template element<2>(); auto nu = V.template element<2>(); //#endif if (!J) J = backend(_name="newtonns")->newMatrix( Vh, Vh ); auto a = form2( _test=Vh, _trial=Vh, _matrix=J ); a = integrate( elements( mesh ), inner(gradt( u ),grad( v ))/Re ); a += integrate( elements( mesh ), id(q)*divt(u) -idt(p)*div(v) ); // Convective terms a += integrate( elements( mesh ), trans(id(v))*gradv(u)*idt(u)); a += integrate( elements( mesh ), trans(id(v))*gradt(u)*idv(u)); //#if defined( FEELPP_USE_LM ) a += integrate(elements(mesh), id(q)*idt(lambda)+idt(p)*id(nu)); //#elif //a += integrate(elements(mesh), idt(p)*id(nu)); //Weak Dirichlet conditions a += integrate( boundaryfaces( mesh ),-trans( -idt(p)*N()+gradt(u)*N()/Re )*id( v ));// a += integrate( boundaryfaces( mesh ),-trans( -id(p)*N()+grad(u)*N()/Re )*idt( u ));// a += integrate( boundaryfaces( mesh ), +penalbc*inner( idt( u ),id( v ) )/hFace() ); }
void TestInterpolationHCurl::testInterpolation( std::string one_element_mesh ) { // expr to interpolate auto myexpr = unitX() + unitY(); //(1,1) // one element mesh auto mesh_name = one_element_mesh + ".msh"; //create the mesh and load it fs::path mesh_path( mesh_name ); mesh_ptrtype oneelement_mesh = loadMesh( _mesh=new mesh_type, _filename=mesh_name); // refined mesh (export) auto refine_level = std::floor(1 - math::log( 0.1 )); //Deduce refine level from meshSize (option) mesh_ptrtype mesh = loadMesh( _mesh=new mesh_type, _filename=mesh_name, _refine=( int )refine_level); space_ptrtype Xh = space_type::New( oneelement_mesh ); std::vector<std::string> faces, edges; //list of edges edges = {"hypo","vert","hor"}; element_type U_h_int = Xh->element(); element_type U_h_on = Xh->element(); element_type U_h_on_boundary = Xh->element(); // handly computed interpolant coeff (in hcurl basis) for ( int i = 0; i < Xh->nLocalDof(); ++i ) { CHECK( oneelement_mesh->hasMarkers( {edges[i]} ) ); U_h_int(i) = integrate( markedfaces( oneelement_mesh, edges[i] ), trans( T() )*myexpr ).evaluate()(0,0); } // nedelec interpolant using on U_h_on.zero(); U_h_on.on(_range=elements(oneelement_mesh), _expr=myexpr); U_h_on_boundary.on(_range=boundaryfaces(oneelement_mesh), _expr=myexpr); auto exporter_proj = exporter( _mesh=mesh, _name=( boost::format( "%1%" ) % this->about().appName() ).str() ); exporter_proj->step( 0 )->add( "U_interpolation_handly_"+mesh_path.stem().string(), U_h_int ); exporter_proj->step( 0 )->add( "U_interpolation_on_"+mesh_path.stem().string(), U_h_on ); exporter_proj->save(); // print coefficient only for reference element U_h_int.printMatlab( "U_h_int_" + mesh_path.stem().string() + ".m" ); U_h_on.printMatlab( "U_h_on_" + mesh_path.stem().string() + ".m" ); U_h_on_boundary.printMatlab( "U_h_on_boundary_" + mesh_path.stem().string() + ".m" ); //L2 norm of error auto error = vf::project(_space=Xh, _range=elements(oneelement_mesh), _expr=idv(U_h_int) - idv(U_h_on) ); double L2error = error.l2Norm(); std::cout << "L2 error (elements) = " << L2error << std::endl; auto error_boundary = vf::project(_space=Xh, _range=boundaryfaces(oneelement_mesh), _expr=idv(U_h_int) - idv(U_h_on_boundary) ); double L2error_boundary = error_boundary.l2Norm(); std::cout << "L2 error (boundary) = " << L2error_boundary << std::endl; BOOST_CHECK_SMALL( L2error_boundary - L2error, 1e-13 ); }
// <int Order_s, int Order_p, int Order_t> void Convection::updateJacobian2( const vector_ptrtype& X, sparse_matrix_ptrtype& D ) { mesh_ptrtype mesh = Xh->mesh(); element_type U( Xh, "u" ); U = *X; LOG(INFO) << "[updateJacobian] ||X|| = " << U.l2Norm() << "\n"; element_type V( Xh, "v" ); element_type W( Xh, "v" ); element_0_type u = U. element<0>(); // fonction vitesse element_0_type v = V. element<0>(); // fonction test vitesse element_1_type p = U. element<1>(); // fonction pression element_1_type q = V. element<1>(); // fonction test pression element_2_type t = U. element<2>(); // fonction temperature element_2_type s = V. element<2>(); // fonction test temperature #if defined( FEELPP_USE_LM ) element_3_type xi = U. element<3>(); // fonction multipliers element_3_type eta = V. element<3>(); // fonction test multipliers #endif double gr= M_current_Grashofs; double sqgr( 1/math::sqrt( gr ) ); double pr = M_current_Prandtl; double sqgrpr=( 1/( pr*math::sqrt( gr ) ) ); double gamma( this->vm()["penalbc"]. as<double>() ); double dt=this->vm()["dt"]. as<double>(); int adim=this->vm()["adim"]. as<int>(); double pC=1; if ( adim == 0 ) pC = this->vm()["pC"]. as<double>(); // // temperature derivatives // // heat convection by the fluid: attention 2 terms form2( _test=Xh, _trial=Xh, _matrix=D ) += integrate ( elements( mesh ), pC*grad( s )*( idv( t )*idt( u ) ) ); form2( _test=Xh, _trial=Xh, _matrix=D ) += integrate ( elements( mesh ), pC*grad( s )*( idt( t )*idv( u ) ) ); form2( _test=Xh, _trial=Xh, _matrix=D ) += integrate ( boundaryfaces( mesh ), pC*( trans( idv( u ) )*N() )*id( s )*idt( t ) ); form2( _test=Xh, _trial=Xh, _matrix=D ) += integrate ( boundaryfaces( mesh ), pC*( trans( idt( u ) )*N() )*id( s )*idv( t ) ); LOG(INFO) << "[updateJacobian2] Temperature convection terms done\n"; LOG(INFO) << "[updateJacobian2] Temperature weak Dirichlet BC terms done\n"; }
boost::tuple<mpl::size_t<MESH_FACES>, typename MeshTraits<MeshType>::location_face_const_iterator, typename MeshTraits<MeshType>::location_face_const_iterator> boundaryfaces( MeshType const& mesh, rank_type __pid, mpl::bool_<true> ) { return boundaryfaces( *mesh, __pid, mpl::bool_<false>() ); }
void DrivenCavity<Dim>::Residual(const vector_ptrtype& X, vector_ptrtype& R) { auto U = Vh->element( "(u,p)" ); auto V = Vh->element( "(v,q)" ); auto u = U.template element<0>( "u" ); //auto u_exact = U.template element<0>( "u_exact" ); auto v = V.template element<0>( "u" ); auto p = U.template element<1>( "p" ); auto q = V.template element<1>( "p" ); //#if defined( FEELPP_USE_LM ) auto lambda = U.template element<2>(); auto nu = V.template element<2>(); //#endif auto uex=unitX(); auto u_exact=vf::project(Vh->template functionSpace<0>(), markedfaces(mesh, "wall2"), uex ); U=*X; auto r = form1( _test=Vh, _vector=R ); //r += integrate( elements( mesh ),-inner( f,id( v ) ) ); r = integrate( elements( mesh ), trans(gradv( u )*idv(u))*id(v));//convective term r += integrate( elements( mesh ), inner(gradv( u ),grad( v ))/Re ); r += integrate( elements( mesh ),-idv(p)*div(v) + id(q)*divv(u)); //#if defined( FEELPP_USE_LM ) r += integrate ( elements( mesh ), +id( q )*idv( lambda )+idv( p )*id( nu ) ); //#endif //Weak Dirichlet auto SigmaNv = ( -idv( p )*N() + gradv( u )*N()/Re ); auto SigmaN = ( -id( q )*N() + grad( v )*N()/Re ); r +=integrate ( boundaryfaces(mesh), - trans( SigmaNv )*id( v ) - trans( SigmaN )*( idv( u ) -idv(u_exact) ) + penalbc*trans( idv( u ) - idv(u_exact) )*id( v )/hFace() ); }
int PreconditionerAS<space_type,coef_space_type>::applyInverse ( const vector_type& X /*R*/, vector_type& Y /*W*/) const { /* * We solve Here P_v w = r * With P_v^-1 = diag(P_m)^-1 (=A) * + P (\bar L + g \bar Q) P^t (=B) * + C (L^-1) C^T (=C) */ U = X; U.close(); // solve equ (12) if ( this->type() == AS ) { tic(); *M_r = U; M_r->close(); // step A : diag(Pm)^-1*r A->pointwiseDivide(*M_r,*M_diagPm); A->close(); // s = P^t r M_Pt->multVector(M_r,M_s); // Impose boundary conditions on M_s #if 1 M_qh3_elt = *M_s; M_qh3_elt.close(); #if FEELPP_DIM == 3 M_qh3_elt.on( _range=boundaryfaces( M_Qh3->mesh() ), _expr=vec(cst(0.), cst(0.), cst(0.)) ); #else M_qh3_elt.on( _range=boundaryfaces( M_Qh3->mesh() ), _expr=vec(cst(0.), cst(0.)) ); #endif *M_s = M_qh3_elt; M_s->close(); #endif #if 1 // Subvectors for M_s (per component) need to be updated M_s1 = M_s->createSubVector(M_Qh3_indices[0], true); M_s2 = M_s->createSubVector(M_Qh3_indices[1], true); #if FEELPP_DIM == 3 M_s3 = M_s->createSubVector(M_Qh3_indices[2], true); #endif #else // s = [ s1, s2, s3 ] M_s->updateSubVector(M_s1, M_Qh3_indices[0]); M_s->updateSubVector(M_s2, M_Qh3_indices[1]); #if FEELPP_DIM == 3 M_s->updateSubVector(M_s3, M_Qh3_indices[2]); #endif #endif M_s->close(); /* * hat(L) + g Q is a (Qh,Qh) matrix * [[ hat(L) + g Q, 0 , 0 ], [ y1 ] [ s1 ] * [ 0, hat(L) + g Q, 0 ], * [ y2 ] = [ s2 ] * [ 0, 0 , hat(L) + g Q ]] [ y3 ] [ s3 ] */ M_lgqOp->applyInverse(M_s1,M_y1); M_lgqOp->applyInverse(M_s2,M_y2); #if FEELPP_DIM == 3 M_lgqOp->applyInverse(M_s3,M_y3); #endif // y = [ y1, y2, y3 ] M_y->updateSubVector(M_y1, M_Qh3_indices[0]); M_y->updateSubVector(M_y2, M_Qh3_indices[1]); #if FEELPP_DIM == 3 M_y->updateSubVector(M_y3, M_Qh3_indices[2]); #endif M_y->close(); // step B : P*y M_P->multVector(M_y,B); // Impose boundary conditions on B = Py #if 1 M_vh_elt = *B; M_vh_elt.close(); #if FEELPP_DIM == 3 M_vh_elt.on( _range=boundaryfaces( M_Qh3->mesh() ), _expr=vec(cst(0.), cst(0.), cst(0.)) ); #else M_vh_elt.on( _range=boundaryfaces( M_Qh3->mesh() ), _expr=vec(cst(0.), cst(0.)) ); #endif *B = M_vh_elt; B->close(); #endif // t = C^t r M_Ct->multVector(M_r,M_t); // Impose boundary conditions on M_t #if 1 M_qh_elt = *M_t; M_qh_elt.close(); M_qh_elt.on( _range=boundaryfaces( M_Qh3->mesh() ), _expr=cst(0.) ); *M_t = M_qh_elt; M_t->close(); #endif // 14.b : hat(L) z = t M_lOp->applyInverse(M_t,M_z); M_z->close(); // step C : M_C z M_C->multVector(M_z,C); C->scale(1./M_g); // Impose boundary conditions on C = Cz #if 1 M_vh_elt = *C; M_vh_elt.close(); #if FEELPP_DIM == 3 M_vh_elt.on( _range=boundaryfaces( M_Qh3->mesh() ), _expr=vec(cst(0.), cst(0.), cst(0.)) ); #else M_vh_elt.on( _range=boundaryfaces( M_Qh3->mesh() ), _expr=vec(cst(0.), cst(0.)) ); #endif *C = M_vh_elt; C->close(); #endif //if(M_g != 1.0) A->add(*C); A->add(*B); C->close(); B->close(); A->close(); toc("assemble preconditioner AS",FLAGS_v>0); *M_uout = *A; // 15 : w = A + B + C } else if( this->type() == SIMPLE ) { SimpleOp->applyInverse(X, Y); *M_uout = Y; } else { Y=U; *M_uout = Y; } M_uout->close(); tic(); Y=*M_uout; Y.close(); toc("PreconditionerAS::applyInverse", FLAGS_v>0 ); return 0; }
void run() { Environment::changeRepository( boost::format( "/testsuite/feeldiscr/%1%/P%2%/" ) % Environment::about().appName() % OrderPoly ); /* change parameters below */ const int nDim = 2; const int nOrderPoly = OrderPoly; const int nOrderGeo = 1; //------------------------------------------------------------------------------// typedef Mesh< Simplex<nDim, 1,nDim> > mesh_type; typedef Mesh< Simplex<nDim, 1,nDim> > mesh_bis_type; double meshSize = option("hsize").as<double>(); double meshSizeBis = option("hsize-bis").as<double>(); // mesh GeoTool::Node x1( 0,0 ); GeoTool::Node x2( 4,1 ); GeoTool::Rectangle Omega( meshSize,"Omega",x1,x2 ); Omega.setMarker( _type="line",_name="Entree",_marker4=true ); Omega.setMarker( _type="line",_name="Sortie",_marker2=true ); Omega.setMarker( _type="line",_name="Paroi",_marker1=true,_marker3=true ); Omega.setMarker( _type="surface",_name="Fluid",_markerAll=true ); auto mesh = Omega.createMesh(_mesh=new mesh_type,_name="omega_"+ mesh_type::shape_type::name() ); LOG(INFO) << "created mesh\n"; GeoTool::Rectangle OmegaBis( meshSizeBis,"Omega",x1,x2 ); OmegaBis.setMarker( _type="line",_name="Entree",_marker4=true ); OmegaBis.setMarker( _type="line",_name="Sortie",_marker2=true ); OmegaBis.setMarker( _type="line",_name="Paroi",_marker1=true,_marker3=true ); OmegaBis.setMarker( _type="surface",_name="Fluid",_markerAll=true ); auto meshBis = OmegaBis.createMesh(_mesh=new mesh_bis_type,_name="omegaBis_"+ mesh_type::shape_type::name() ); //auto meshBis= mesh->createP1mesh(); LOG(INFO) << "created meshBis\n"; typedef Lagrange<nOrderPoly,Scalar,Continuous,PointSetFekete> basis_type; typedef FunctionSpace<mesh_type, bases<basis_type> > space_type; auto Xh = space_type::New( mesh ); auto u = Xh->element(); auto v = Xh->element(); auto u2 = Xh->element(); LOG(INFO) << "created space and elements\n"; auto mybackend = backend(); //--------------------------------------------------------------// auto A = mybackend->newMatrix( Xh, Xh ); auto F = mybackend->newVector( Xh ); auto pi = cst( M_PI ); auto u_exact = cos( pi*Px() )*sin( pi*Py() ); auto dudx = -pi*sin( pi*Px() )*sin( pi*Py() ); auto dudy = pi*cos( pi*Px() )*cos( pi*Py() ); auto grad_u_uexact = vec( dudx,dudy ); auto lap = -2*pi*pi*cos( pi*Px() )*sin( pi*Py() ); //auto lap = -pi*pi*cos(pi*Px())*sin(pi*Py()) // -pi*pi*cos(pi*Px())*sin(pi*Py()); LOG(INFO) << "created exact data and matrix/vector\n"; auto f = -lap;//cst(1.); double gammabc=10; // assemblage form2( Xh, Xh, A, _init=true ) = integrate( elements( mesh ), //_Q<15>(), + gradt( u )*trans( grad( v ) ) ); form2( Xh, Xh, A ) += integrate( boundaryfaces( mesh ), - gradt( u )*N()*id( v ) + gammabc*idt( u )*id( v )/hFace() ); form1( Xh, F, _init=true ) = integrate( elements( mesh ), // _Q<10>(), trans( f )*id( v ) ); form1( Xh, F ) += integrate( boundaryfaces( mesh ), + gammabc*u_exact*id( v )/hFace() ); LOG(INFO) << "A,F assembled\n"; //form2( Xh, Xh, A ) += // on( boundaryfaces(mesh) , u, F, u_exact ); // solve system mybackend->solve( A,u,F ); LOG(INFO) << "A u = F solved\n"; //--------------------------------------------------------------// auto a2 = form2( _test=Xh, _trial=Xh ); auto f2 = form1( _test=Xh ); LOG(INFO) << "created form2 a2 and form1 F2\n"; // assemblage a2 = integrate( elements( meshBis ), + gradt( u2 )*trans( grad( v ) ), _Q<10>() ); LOG(INFO) << "a2 grad.grad term\n"; a2 += integrate( boundaryfaces( meshBis ), - gradt( u2 )*N()*id( v ) + gammabc*idt( u2 )*id( v )/hFace(), _Q<10>() ); LOG(INFO) << "a2 weak dirichlet terms\n"; f2 = integrate( elements( meshBis ), trans( f )*id( v ), _Q<10>() ); LOG(INFO) << "f2 source term\n"; f2 += integrate( boundaryfaces( meshBis ), + gammabc*u_exact*id( v )/hFace(), _Q<10>() ); LOG(INFO) << "f2 dirichlet terms\n"; LOG(INFO) << "a2,f2 assembled\n"; //form2( Xh, Xh, A2 ) += // on( boundaryfaces(mesh) , u2, F2, u_exact ); #if 0 for ( size_type i = 0 ; i< F->size() ; ++i ) { auto errOnF = std::abs( ( *F )( i )-( *F2 )( i ) ); if ( errOnF > 1e-8 ) std::cout << "\nerrOnF : " << errOnF; } std::cout << "\nFin errOnF !!!!\n"; #endif // solve system a2.solve( _rhs=f2, _solution=u2 ); auto diff = std::sqrt( integrate( elements( mesh ), ( idv( u )-idv( u2 ) )*( idv( u )-idv( u2 ) ) ).evaluate()( 0,0 ) ); #if 0 auto int1 = integrate( elements( mesh ), abs( idv( u ) ) ).evaluate()( 0,0 ); auto int2 = integrate( elements( mesh ), abs( idv( u2 ) ) ).evaluate()( 0,0 ); std::cout << "\nThe diff : " << diff << " int1 :" << int1 << " int2 :" << int2 << "\n"; #endif #if USE_BOOST_TEST BOOST_CHECK_SMALL( diff,1e-2 ); #endif //--------------------------------------------------------------// if ( option("exporter.export").as<bool>() ) { // export auto ex = exporter( _mesh=mesh ); ex->add( "u", u ); ex->add( "ubis", u2 ); ex->save(); } }
void NavierStokes::run() { this->init(); auto U = Xh->element( "(u,p)" ); auto V = Xh->element( "(u,q)" ); auto u = U.element<0>( "u" ); auto v = V.element<0>( "u" ); auto p = U.element<1>( "p" ); auto q = V.element<1>( "p" ); #if defined( FEELPP_USE_LM ) auto lambda = U.element<2>(); auto nu = V.element<2>(); #endif //# endmarker4 # LOG(INFO) << "[dof] number of dof: " << Xh->nDof() << "\n"; LOG(INFO) << "[dof] number of dof/proc: " << Xh->nLocalDof() << "\n"; LOG(INFO) << "[dof] number of dof(U): " << Xh->functionSpace<0>()->nDof() << "\n"; LOG(INFO) << "[dof] number of dof/proc(U): " << Xh->functionSpace<0>()->nLocalDof() << "\n"; LOG(INFO) << "[dof] number of dof(P): " << Xh->functionSpace<1>()->nDof() << "\n"; LOG(INFO) << "[dof] number of dof/proc(P): " << Xh->functionSpace<1>()->nLocalDof() << "\n"; LOG(INFO) << "Data Summary:\n"; LOG(INFO) << " hsize = " << meshSize << "\n"; LOG(INFO) << " export = " << this->vm().count( "export" ) << "\n"; LOG(INFO) << " mu = " << mu << "\n"; LOG(INFO) << " bccoeff = " << penalbc << "\n"; //# marker5 # auto deft = gradt( u )+trans(gradt(u)); auto def = grad( v )+trans(grad(v)); //# endmarker5 # //# marker6 # // total stress tensor (trial) auto SigmaNt = -idt( p )*N()+mu*deft*N(); // total stress tensor (test) auto SigmaN = -id( p )*N()+mu*def*N(); //# endmarker6 # auto F = M_backend->newVector( Xh ); auto D = M_backend->newMatrix( Xh, Xh ); // right hand side auto ns_rhs = form1( _test=Xh, _vector=F ); LOG(INFO) << "[navier-stokes] vector local assembly done\n"; // construction of the BDF auto bdfns=bdf(_space=Xh); /* * Construction of the left hand side */ auto navierstokes = form2( _test=Xh, _trial=Xh, _matrix=D ); mpi::timer chrono; navierstokes += integrate( elements( mesh ), mu*inner( deft,def )+ trans(idt( u ))*id( v )*bdfns->polyDerivCoefficient( 0 ) ); LOG(INFO) << "mu*inner(deft,def)+(bdf(u),v): " << chrono.elapsed() << "\n"; chrono.restart(); navierstokes +=integrate( elements( mesh ), - div( v )*idt( p ) + divt( u )*id( q ) ); LOG(INFO) << "(u,p): " << chrono.elapsed() << "\n"; chrono.restart(); #if defined( FEELPP_USE_LM ) navierstokes +=integrate( elements( mesh ), id( q )*idt( lambda ) + idt( p )*id( nu ) ); LOG(INFO) << "(lambda,p): " << chrono.elapsed() << "\n"; chrono.restart(); #endif std::for_each( inflow_conditions.begin(), inflow_conditions.end(), [&]( BoundaryCondition const& bc ) { // right hand side ns_rhs += integrate( markedfaces( mesh, bc.marker() ), inner( idf(&bc,BoundaryCondition::operator()),-SigmaN+penalbc*id( v )/hFace() ) ); navierstokes +=integrate( boundaryfaces( mesh ), -inner( SigmaNt,id( v ) ) ); navierstokes +=integrate( boundaryfaces( mesh ), -inner( SigmaN,idt( u ) ) ); navierstokes +=integrate( boundaryfaces( mesh ), +penalbc*inner( idt( u ),id( v ) )/hFace() ); }); std::for_each( wall_conditions.begin(), wall_conditions.end(), [&]( BoundaryCondition const& bc ) { navierstokes +=integrate( boundaryfaces( mesh ), -inner( SigmaNt,id( v ) ) ); navierstokes +=integrate( boundaryfaces( mesh ), -inner( SigmaN,idt( u ) ) ); navierstokes +=integrate( boundaryfaces( mesh ), +penalbc*inner( idt( u ),id( v ) )/hFace() ); }); std::for_each( outflow_conditions.begin(), outflow_conditions.end(), [&]( BoundaryCondition const& bc ) { ns_rhs += integrate( markedfaces( mesh, bc.marker() ), inner( idf(&bc,BoundaryCondition::operator()),N() ) ); }); LOG(INFO) << "bc: " << chrono.elapsed() << "\n"; chrono.restart(); u = vf::project( _space=Xh->functionSpace<0>(), _expr=cst(0.) ); p = vf::project( _space=Xh->functionSpace<1>(), _expr=cst(0.) ); M_bdf->initialize( U ); for( bdfns->start(); bdfns->isFinished(); bdfns->next() ) { // add time dependent terms auto bdf_poly = bdfns->polyDeriv(); form1( _test=Xh, _vector=Ft ) = integrate( _range=elements(mesh), _expr=trans(idv( bdf_poly ))*id( v ) ); // add convective terms form1( _test=Xh, _vector=Ft ) += integrate( _range=elements(mesh), _expr=trans(gradv(u)*idv( u ))*id(v) ); // add contrib from time independent terms Ft->add( 1., F ); // add time stepping terms from BDF to right hand side backend()->solve( _matrix=D, _solution=U, _rhs=Ft ); this->exportResults( bdfns->time(), U ); } } // NavierNavierstokes::run
void TestInterpolationHCurl3D::testInterpolation( std::string one_element_mesh ) { //auto myexpr = unitX() + unitY() + unitZ() ; //(1,1,1) auto myexpr = vec( cst(1.), cst(1.), cst(1.)); // one element mesh auto mesh_name = one_element_mesh + ".msh"; //create the mesh and load it fs::path mesh_path( mesh_name ); mesh_ptrtype oneelement_mesh = loadMesh( _mesh=new mesh_type, _filename=mesh_name); // refined mesh (export) auto refine_level = std::floor(1 - math::log( 0.1 )); //Deduce refine level from meshSize (option) mesh_ptrtype mesh = loadMesh( _mesh=new mesh_type, _filename=mesh_name, _refine=( int )refine_level); space_ptrtype Xh = space_type::New( oneelement_mesh ); std::vector<std::string> faces = {"yzFace","xyzFace","xyFace"}; std::vector<std::string> edges = {"zAxis","yAxis","yzAxis","xyAxis","xzAxis","xAxis"}; element_type U_h_int = Xh->element(); element_type U_h_on = Xh->element(); element_type U_h_on_boundary = Xh->element(); submesh1d_ptrtype edgeMesh( new submesh1d_type ); edgeMesh = createSubmesh(oneelement_mesh, boundaryedges(oneelement_mesh) ); //submesh of edges // Tangents on ref element auto t0 = vec(cst(0.),cst(0.),cst(-2.)); auto t1 = vec(cst(0.),cst(2.),cst(0.)); auto t2 = vec(cst(0.),cst(-2.),cst(2.)); auto t3 = vec(cst(2.),cst(-2.),cst(0.)); auto t4 = vec(cst(2.),cst(0.),cst(-2.)); auto t5 = vec(cst(2.),cst(0.),cst(0.)); // Jacobian of geometrical transforms std::string jac; if(mesh_path.stem().string() == "one-elt-ref-3d" || mesh_path.stem().string() == "one-elt-real-h**o-3d" ) jac = "{1,0,0,0,1,0,0,0,1}:x:y:z"; else if(mesh_path.stem().string() == "one-elt-real-rotx" ) jac = "{1,0,0,0,0,-1,0,1,0}:x:y:z"; else if(mesh_path.stem().string() == "one-elt-real-roty" ) jac = "{0,0,1,0,1,0,-1,0,0}:x:y:z"; else if(mesh_path.stem().string() == "one-elt-real-rotz" ) jac = "{0,-1,0,1,0,0,0,0,1}:x:y:z"; U_h_int(0) = integrate( markedelements(edgeMesh, edges[0]), trans(expr<3,3>(jac)*t0)*myexpr ).evaluate()(0,0); U_h_int(1) = integrate( markedelements(edgeMesh, edges[1]), trans(expr<3,3>(jac)*t1)*myexpr ).evaluate()(0,0); U_h_int(2) = integrate( markedelements(edgeMesh, edges[2]), trans(expr<3,3>(jac)*t2)*myexpr ).evaluate()(0,0); U_h_int(3) = integrate( markedelements(edgeMesh, edges[3]), trans(expr<3,3>(jac)*t3)*myexpr ).evaluate()(0,0); U_h_int(4) = integrate( markedelements(edgeMesh, edges[4]), trans(expr<3,3>(jac)*t4)*myexpr ).evaluate()(0,0); U_h_int(5) = integrate( markedelements(edgeMesh, edges[5]), trans(expr<3,3>(jac)*t5)*myexpr ).evaluate()(0,0); for(int i=0; i<edges.size(); i++) { double edgeLength = integrate( markedelements(edgeMesh, edges[i]), cst(1.) ).evaluate()(0,0); U_h_int(i) /= edgeLength; } #if 0 //Doesn't work for now for(int i=0; i<Xh->nLocalDof(); i++) { CHECK( edgeMesh->hasMarkers( {edges[i]} ) ); U_h_int(i) = integrate( markedelements(edgeMesh, edges[i]), trans( print(T(),"T=") )*myexpr ).evaluate()(0,0); std::cout << "U_h_int(" << i << ")= " << U_h_int(i) << std::endl; } #endif // nedelec interpolant using on keyword // interpolate on element U_h_on.zero(); U_h_on.on(_range=elements(oneelement_mesh), _expr=myexpr); U_h_on_boundary.on(_range=boundaryfaces(oneelement_mesh), _expr=myexpr); auto exporter_proj = exporter( _mesh=mesh, _name=( boost::format( "%1%" ) % this->about().appName() ).str() ); exporter_proj->step( 0 )->add( "U_interpolation_handly_"+mesh_path.stem().string(), U_h_int ); exporter_proj->step( 0 )->add( "U_interpolation_on_"+mesh_path.stem().string(), U_h_on ); exporter_proj->save(); // print coefficient only for reference element U_h_int.printMatlab( "U_h_int_" + mesh_path.stem().string() + ".m" ); U_h_on.printMatlab( "U_h_on_" + mesh_path.stem().string() + ".m" ); U_h_on_boundary.printMatlab( "U_h_on_boundary_" + mesh_path.stem().string() + ".m" ); //L2 norm of error auto error = vf::project(_space=Xh, _range=elements(oneelement_mesh), _expr=idv(U_h_int) - idv(U_h_on) ); double L2error = error.l2Norm(); std::cout << "L2 error (elements) = " << L2error << std::endl; auto error_boundary = vf::project(_space=Xh, _range=elements(oneelement_mesh), _expr=idv(U_h_int) - idv(U_h_on_boundary) ); double L2error_boundary = error_boundary.l2Norm(); std::cout << "L2 error (boundary) = " << L2error_boundary << std::endl; BOOST_CHECK_SMALL( L2error_boundary - L2error, 1e-13 ); }
void Partitioning<Dim>::run() { int p = 2; int* pm = new int[p]; for(unsigned short i = 0; i < p; ++i) pm[i] = i * (Environment::numberOfProcessors() / p); bool excluded = std::binary_search(pm, pm + p, Environment::rank()); mpi::group new_group; if(excluded) new_group = Environment::worldComm().group().include(pm,pm+p); else new_group = Environment::worldComm().group().exclude(pm,pm+p); delete [] pm; boost::mpi::communicator bComm(Environment::worldComm(), new_group); std::vector<int> active( bComm.size(), true ); WorldComm wComm(bComm,bComm,bComm,bComm.rank(),active); //wComm.showMe(); boost::shared_ptr<Mesh<Simplex<Dim>>> mesh; if(!excluded) { std::cout << "proc " << Environment::rank() << " is not excluded and is locally rank " << wComm.rank() << " and loads mesh with " << wComm.globalSize() << " partitions\n"; // mesh = loadMesh(_mesh = new Mesh<Simplex<Dim>>(wComm), _worldcomm=wComm ); mesh = createGMSHMesh(_mesh = new Mesh<Simplex<Dim>>(wComm), _worldcomm = wComm, _desc = domain(_worldcomm = wComm, _name = "hypercube", _shape = "hypercube", _xmin = 0.0, _xmax = 1.0, _ymin = 0.0, _ymax = 1.0, _zmin = 0.0, _zmax = 1.0)); std::cout << " - nelement(mesh)=" << nelements(elements(mesh)) << "\n"; std::cout << " - loading space\n"; auto Vh = Pch<2>( mesh ); auto u = Vh->element("u"); auto f = expr( soption(_name="functions.f"), "f", wComm ); auto g = expr( soption(_name="functions.g"), "g", wComm ); auto v = Vh->element( g, "g" ); auto l = form1( _test=Vh ); l = integrate(_range=elements(mesh),_expr=f*id(v)); auto a = form2( _trial=Vh, _test=Vh); a = integrate(_range=elements(mesh), _expr=gradt(u)*trans(grad(v)) ); if(boption("gmsh.domain.usenames")) { if(nelements(markedfaces(mesh, "Dirichlet"), boption("use_global")) > 0) a+=on(_range=markedfaces(mesh, "Dirichlet"), _rhs=l, _element=u, _expr=g); } else a+=on(_range=boundaryfaces(mesh), _rhs=l, _element=u, _expr=g); a.solve(_rhs=l,_solution=u); auto e = exporter( _mesh=mesh ); //e->addRegions(); e->add( "u", u ); e->add( "g", v ); e->save(); } else { std::cout << "proc " << Environment::rank() << " is excluded and does not load mesh"; int np = 0; mpi::all_reduce(wComm, 1, np, std::plus<int>()); std::cout << "proc " << Environment::rank() << " - nb proc = " << np << "\n"; } } // Partitioning::run