//fill a vector to have the container virtual void containerPtr( vector_ptrtype & vector_to_fill ) { auto vector = M_backend->newVector( this->space() ); form1( _test=this->space(),_vector=vector) = M_expr; vector->close(); vector_to_fill = vector; }
static inline void assemble(boost::shared_ptr<Mesh<Simplex<Dim>>>& mesh, double* vec) { boost::timer time; auto Vh = FunctionSpace<Mesh<Simplex<Dim>>, bases<Lagrange<Order, Type>>>::New(_mesh = mesh); vec[2] = time.elapsed(); vec[1] = Vh->nDof(); Environment::logMemoryUsage( "Assemble Laplacian Memory Usage: FunctionSpace" ); time.restart(); auto v = Vh->element(); auto f = backend()->newVector(Vh); auto l = form1(_test = Vh, _vector = f); l = integrate(_range = elements(mesh), _expr = id(v)); vec[4] = time.elapsed(); Environment::logMemoryUsage( "Assemble Laplacian Memory Usage: Form1" ); time.restart(); auto u = Vh->element(); auto A = backend()->newMatrix(Vh, Vh); vec[5] = time.elapsed(); Environment::logMemoryUsage( "Assemble Laplacian Memory Usage: Matrix" ); time.restart(); auto a = form2(_trial = Vh, _test = Vh, _matrix = A); a = integrate(_range = elements(mesh), _expr = inner(gradt(u),grad(v))); a += on(_range = markedfaces(mesh, "Dirichlet"), _rhs = l, _element = u, _expr = cst(0.0)); vec[3] = time.elapsed(); auto mem = Environment::logMemoryUsage( "Assemble Laplacian Memory Usage: form2" ); v[6] = mem.memory_usage/1e9; LOG(INFO) << "v[6] = " << v[6]; cleanup(); }
void PreconditionerBlockMS<space_type>::init( void ) { if( Environment::worldComm().isMasterRank() ) std::cout << "Init preconditioner blockms\n"; LOG(INFO) << "Init ...\n"; tic(); BoundaryConditions M_bc = M_model.boundaryConditions(); LOG(INFO) << "Create sub Matrix\n"; map_vector_field<FEELPP_DIM,1,2> m_dirichlet_u { M_bc.getVectorFields<FEELPP_DIM> ( "u", "Dirichlet" ) }; map_scalar_field<2> m_dirichlet_p { M_bc.getScalarFields<2> ( "phi", "Dirichlet" ) }; /* * AA = [[ A - k^2 M, B^t], * [ B , 0 ]] * We need to extract A-k^2 M and add it M to form A+(1-k^2) M = A+g M */ // Is the zero() necessary ? M_11->zero(); this->matrix()->updateSubMatrix(M_11, M_Vh_indices, M_Vh_indices, false); // M_11 = A-k^2 M LOG(INFO) << "Use relax = " << M_relax << std::endl; M_11->addMatrix(M_relax,M_mass); // A-k^2 M + M_relax*M = A+(M_relax-k^2) M auto f2A = form2(_test=M_Vh, _trial=M_Vh,_matrix=M_11); auto f1A = form1(_test=M_Vh); for(auto const & it : m_dirichlet_u ) f2A += on(_range=markedfaces(M_Vh->mesh(),it.first), _expr=it.second,_rhs=f1A, _element=u, _type="elimination_symmetric"); /* * Rebuilding sub-backend */ backend(_name=M_prefix_11, _rebuild=true); backend(_name=M_prefix_22, _rebuild=true); // We have to set the G, Px,Py,Pz or X,Y,Z matrices to AMS if(soption(_name="pc-type", _prefix=M_prefix_11) == "ams") { #if FEELPP_DIM == 3 initAMS(); { if(boption(_name="setAlphaBeta",_prefix=M_prefix_11)) { auto prec = preconditioner(_pc=pcTypeConvertStrToEnum(soption(M_prefix_11+".pc-type")), _backend=backend(_name=M_prefix_11), _prefix=M_prefix_11, _matrix=M_11 ); prec->setMatrix(M_11); prec->attachAuxiliarySparseMatrix("a_alpha",M_a_alpha); prec->attachAuxiliarySparseMatrix("a_beta",M_a_beta); } } #else std::cerr << "ams preconditioner is not interfaced in two dimensions\n"; #endif } toc("[PreconditionerBlockMS] Init",FLAGS_v>0); LOG(INFO) << "Init done\n"; }
// apply the functional virtual value_type operator()( const element_type& x ) const { auto vector = M_backend->newVector( this->space() ); form1( _test=this->space(),_vector=vector) = M_expr; vector->close(); return M_backend->dot( *vector, x.container() ); }
int main(void) { Form form1("form1", 5, 5); Form form2("form2", 10, 5); Bureaucrat bob("bob", 1); Bureaucrat roger("roger", 6); std::cout << form1 << form2 << bob << roger; bob.signForm(form1); std::cout << form1 << form2 << bob << roger; bob.signForm(form2); std::cout << form1 << form2 << bob << roger; roger.signForm(form1); std::cout << form1 << form2 << bob << roger; roger.signForm(form2); std::cout << form1 << form2 << bob << roger; return (0); }
static inline void assemble(boost::shared_ptr<Mesh<Simplex<Dim>>>& mesh, double* vec) { boost::timer time; auto Vh = FunctionSpace<Mesh<Simplex<Dim>>, bases<Lagrange<Order, Type>, Lagrange<OrderBis, TypeBis>>>::New(_mesh = mesh, _worldscomm = std::vector<WorldComm>(2, mesh->worldComm()), _extended_doftable = std::vector<bool>(2, false)); vec[2] = time.elapsed(); Environment::logMemoryUsage( "Assemble Stokes Memory Usage: FunctionSpace" ); vec[1] = Vh->nDof(); time.restart(); auto V = Vh->element(); auto v = V.template element<0>(); auto f = backend()->newVector(Vh); auto l = form1(_test = Vh, _vector = f); l = integrate(_range = elements(mesh), _expr = trans(oneY()) * id(v)); vec[4] = time.elapsed(); Environment::logMemoryUsage( "Assemble Stokes Memory Usage: Form1" ); time.restart(); auto U = Vh->element(); auto u = U.template element<0>(); auto p = U.template element<1>(); auto q = V.template element<1>(); auto A = backend()->newMatrix(Vh, Vh); vec[5] = time.elapsed(); Environment::logMemoryUsage( "Assemble Stokes Memory Usage: Matrix" ); time.restart(); auto a = form2(_trial = Vh, _test = Vh, _matrix = A); a = integrate(_range = elements(mesh), _expr = trace(gradt(u) * trans(grad(v)))); a += integrate(_range = elements(mesh), _expr = - div(v) * idt(p) ); a += integrate(_range = elements(mesh), _expr = - divt(u) * id(q)); a += on(_range = markedfaces(mesh, "Dirichlet"), _rhs = l, _element = u, _expr = zero<Dim, 1>()); vec[3] = time.elapsed(); auto mem = Environment::logMemoryUsage( "Assemble Stokes Memory Usage: Form2" ); v[6] = mem.memory_usage/1.e9; cleanup(); }
bool exprs_for_24(int a1, int a2, int a3, int a4) { int ar[4] = {a1, a2, a3, a4}; sort_quick(4, ar); int ops[4] = {'+', '-', '*', '/'}; int opr[3]; Rpermut rp(3, opr, sizeof(ops)/sizeof(int), ops); int a, b, c, d; int op1, op2, op3; bool found = false; for (; std::next_permutation(ar, ar+4); ) { a = ar[0]; b = ar[1]; c = ar[2]; d = ar[3]; for (rp.begin(); !rp.ended; rp.next()) { op1 = opr[0]; op2 = opr[1]; op3 = opr[2]; if (form1(a, b, c, d, op1, op2, op3) || form2(a, b, c, d, op1, op2, op3) || form3(a, b, c, d, op1, op2, op3) || form4(a, b, c, d, op1, op2, op3) || form5(a, b, c, d, op1, op2, op3)) found = true; } } return found; }
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() ); }
static inline void assemble(boost::shared_ptr<Mesh<Simplex<Dim>>>& mesh, double* vec) { boost::timer time; //HeapProfilerStart("FunctionSpace"); auto Vh = FunctionSpace<Mesh<Simplex<Dim>>, bases<Lagrange<Order, Type>>>::New(_mesh = mesh); //HeapProfilerDump("dump"); //HeapProfilerStop(); vec[2] = time.elapsed(); Environment::logMemoryUsage( "Assemble Elasticity Memory Usage: FunctionSpace" ); vec[1] = Vh->nDof(); auto E = 1e+8; auto nu = 0.25; auto mu = E / (2 * (1 + nu)); auto lambda = E * nu / ((1 + nu) * (1 - 2 * nu)); time.restart(); auto v = Vh->element(); auto f = backend()->newVector(Vh); auto l = form1(_test = Vh, _vector = f); l = integrate(_range = elements(mesh), _expr = -1e+3 * trans(oneY()) * id(v)); vec[4] = time.elapsed(); Environment::logMemoryUsage( "Assemble Elasticity Memory Usage: Form1" ); time.restart(); auto u = Vh->element(); auto A = backend()->newMatrix(Vh, Vh); vec[5] = time.elapsed(); Environment::logMemoryUsage( "Assemble Elasticity Memory Usage: Matrix" ); time.restart(); auto a = form2(_trial = Vh, _test = Vh, _matrix = A); a = integrate(_range = elements(mesh), _expr = lambda * divt(u) * div(v) + 2 * mu * trace(trans(sym(gradt(u))) * sym(grad(u)))); a += on(_range = markedfaces(mesh, "Dirichlet"), _rhs = l, _element = u, _expr = zero<Dim, 1>()); vec[3] = time.elapsed(); auto mem = Environment::logMemoryUsage( "Assemble Elasticity Memory Usage: Form2" ); v[6] = mem.memory_usage/1e9; cleanup(); }
this_type& operator+=( ExprT const& e ) { form1( _test=this->space(), _vector=M_vector ) += e; return *this; }
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
PreconditionerBlockMS<space_type>::PreconditionerBlockMS(space_ptrtype Xh, // (u)x(p) ModelProperties model, // model std::string const& p, // prefix sparse_matrix_ptrtype AA ) // The matrix : M_backend(backend()), // the backend associated to the PC M_Xh( Xh ), M_Vh( Xh->template functionSpace<0>() ), // Potential M_Qh( Xh->template functionSpace<1>() ), // Lagrange M_Vh_indices( M_Vh->nLocalDofWithGhost() ), M_Qh_indices( M_Qh->nLocalDofWithGhost() ), M_uin( M_backend->newVector( M_Vh ) ), M_uout( M_backend->newVector( M_Vh ) ), M_pin( M_backend->newVector( M_Qh ) ), M_pout( M_backend->newVector( M_Qh ) ), U( M_Xh, "U" ), M_mass(M_backend->newMatrix(M_Vh,M_Vh)), M_L(M_backend->newMatrix(M_Qh,M_Qh)), M_er( 1. ), M_model( model ), M_prefix( p ), M_prefix_11( p+".11" ), M_prefix_22( p+".22" ), u(M_Vh, "u"), ozz(M_Vh, "ozz"), zoz(M_Vh, "zoz"), zzo(M_Vh, "zzo"), M_ozz(M_backend->newVector( M_Vh )), M_zoz(M_backend->newVector( M_Vh )), M_zzo(M_backend->newVector( M_Vh )), X(M_Qh, "X"), Y(M_Qh, "Y"), Z(M_Qh, "Z"), M_X(M_backend->newVector( M_Qh )), M_Y(M_backend->newVector( M_Qh )), M_Z(M_backend->newVector( M_Qh )), phi(M_Qh, "phi") { tic(); LOG(INFO) << "[PreconditionerBlockMS] setup starts"; this->setMatrix( AA ); this->setName(M_prefix); /* Indices are need to extract sub matrix */ std::iota( M_Vh_indices.begin(), M_Vh_indices.end(), 0 ); std::iota( M_Qh_indices.begin(), M_Qh_indices.end(), M_Vh->nLocalDofWithGhost() ); M_11 = AA->createSubMatrix( M_Vh_indices, M_Vh_indices, true, true); /* Boundary conditions */ BoundaryConditions M_bc = M_model.boundaryConditions(); map_vector_field<FEELPP_DIM,1,2> m_dirichlet_u { M_bc.getVectorFields<FEELPP_DIM> ( "u", "Dirichlet" ) }; map_scalar_field<2> m_dirichlet_p { M_bc.getScalarFields<2> ( "phi", "Dirichlet" ) }; /* Compute the mass matrix (needed in first block, constant) */ auto f2A = form2(_test=M_Vh, _trial=M_Vh, _matrix=M_mass); auto f1A = form1(_test=M_Vh); f2A = integrate(_range=elements(M_Vh->mesh()), _expr=inner(idt(u),id(u))); // M for(auto const & it : m_dirichlet_u ) { LOG(INFO) << "Applying " << it.second << " on " << it.first << " for "<<M_prefix_11<<"\n"; f2A += on(_range=markedfaces(M_Vh->mesh(),it.first), _expr=it.second,_rhs=f1A, _element=u, _type="elimination_symmetric"); } /* Compute the L (= er * grad grad) matrix (the second block) */ auto f2L = form2(_test=M_Qh,_trial=M_Qh, _matrix=M_L); for(auto it : M_model.materials() ) { f2L += integrate(_range=markedelements(M_Qh->mesh(),marker(it)), _expr=M_er*inner(gradt(phi), grad(phi))); } auto f1LQ = form1(_test=M_Qh); for(auto const & it : m_dirichlet_p) { LOG(INFO) << "Applying " << it.second << " on " << it.first << " for "<<M_prefix_22<<"\n"; f2L += on(_range=markedfaces(M_Qh->mesh(),it.first),_element=phi, _expr=it.second, _rhs=f1LQ, _type="elimination_symmetric"); } if(soption(_name="pc-type", _prefix=M_prefix_11) == "ams") #if FEELPP_DIM == 3 { M_grad = Grad( _domainSpace=M_Qh, _imageSpace=M_Vh); // This preconditioner is linked to that backend : the backend will // automatically use the preconditioner. auto prec = preconditioner(_pc=pcTypeConvertStrToEnum(soption(M_prefix_11+".pc-type")), _backend=backend(_name=M_prefix_11), _prefix=M_prefix_11, _matrix=M_11 ); prec->setMatrix(M_11); prec->attachAuxiliarySparseMatrix("G",M_grad.matPtr()); if(boption(M_prefix_11+".useEdge")) { LOG(INFO) << "[ AMS ] : using SetConstantEdgeVector \n"; ozz.on(_range=elements(M_Vh->mesh()),_expr=vec(cst(1),cst(0),cst(0))); zoz.on(_range=elements(M_Vh->mesh()),_expr=vec(cst(0),cst(1),cst(0))); zzo.on(_range=elements(M_Vh->mesh()),_expr=vec(cst(0),cst(0),cst(1))); *M_ozz = ozz; M_ozz->close(); *M_zoz = zoz; M_zoz->close(); *M_zzo = zzo; M_zzo->close(); prec->attachAuxiliaryVector("Px",M_ozz); prec->attachAuxiliaryVector("Py",M_zoz); prec->attachAuxiliaryVector("Pz",M_zzo); } else { LOG(INFO) << "[ AMS ] : using SetCoordinates \n"; X.on(_range=elements(M_Vh->mesh()),_expr=Px()); Y.on(_range=elements(M_Vh->mesh()),_expr=Py()); Z.on(_range=elements(M_Vh->mesh()),_expr=Pz()); *M_X = X; M_X->close(); *M_Y = Y; M_Y->close(); *M_Z = Z; M_Z->close(); prec->attachAuxiliaryVector("X",M_X); prec->attachAuxiliaryVector("Y",M_Y); prec->attachAuxiliaryVector("Z",M_Z); } } #else std::cerr << "ams preconditioner is not interfaced in two dimensions\n"; #endif toc( "[PreconditionerBlockMS] setup done ", FLAGS_v > 0 ); }
PreconditionerBlockMS<space_type>::PreconditionerBlockMS(space_ptrtype Xh, // (u)x(p) ModelProperties model, // model std::string const& p, // prefix sparse_matrix_ptrtype AA, value_type relax ) // The matrix : M_backend(backend()), // the backend associated to the PC M_Xh( Xh ), M_Vh( Xh->template functionSpace<0>() ), // Potential M_Qh( Xh->template functionSpace<1>() ), // Lagrange M_Vh_indices( M_Vh->nLocalDofWithGhost() ), M_Qh_indices( M_Qh->nLocalDofWithGhost() ), M_uin( M_backend->newVector( M_Vh ) ), M_uout( M_backend->newVector( M_Vh ) ), M_pin( M_backend->newVector( M_Qh ) ), M_pout( M_backend->newVector( M_Qh ) ), U( M_Xh, "U" ), M_mass(M_backend->newMatrix(M_Vh,M_Vh)), M_L(M_backend->newMatrix(M_Qh,M_Qh)), M_er( 1. ), M_model( model ), M_prefix( p ), M_prefix_11( p+".11" ), M_prefix_22( p+".22" ), u(M_Vh, "u"), ozz(M_Vh, "ozz"), zoz(M_Vh, "zoz"), zzo(M_Vh, "zzo"), M_ozz(M_backend->newVector( M_Vh )), M_zoz(M_backend->newVector( M_Vh )), M_zzo(M_backend->newVector( M_Vh )), X(M_Qh, "X"), Y(M_Qh, "Y"), Z(M_Qh, "Z"), M_X(M_backend->newVector( M_Qh )), M_Y(M_backend->newVector( M_Qh )), M_Z(M_backend->newVector( M_Qh )), phi(M_Qh, "phi"), M_relax(relax) { tic(); LOG(INFO) << "[PreconditionerBlockMS] setup starts"; this->setMatrix( AA ); this->setName(M_prefix); /* Indices are need to extract sub matrix */ std::iota( M_Vh_indices.begin(), M_Vh_indices.end(), 0 ); std::iota( M_Qh_indices.begin(), M_Qh_indices.end(), M_Vh->nLocalDofWithGhost() ); M_11 = AA->createSubMatrix( M_Vh_indices, M_Vh_indices, true, true); /* Boundary conditions */ BoundaryConditions M_bc = M_model.boundaryConditions(); map_vector_field<FEELPP_DIM,1,2> m_dirichlet_u { M_bc.getVectorFields<FEELPP_DIM> ( "u", "Dirichlet" ) }; map_scalar_field<2> m_dirichlet_p { M_bc.getScalarFields<2> ( "phi", "Dirichlet" ) }; /* Compute the mass matrix (needed in first block, constant) */ auto f2A = form2(_test=M_Vh, _trial=M_Vh, _matrix=M_mass); auto f1A = form1(_test=M_Vh); f2A = integrate(_range=elements(M_Vh->mesh()), _expr=inner(idt(u),id(u))); // M for(auto const & it : m_dirichlet_u ) { LOG(INFO) << "Applying " << it.second << " on " << it.first << " for "<<M_prefix_11<<"\n"; f2A += on(_range=markedfaces(M_Vh->mesh(),it.first), _expr=it.second,_rhs=f1A, _element=u, _type="elimination_symmetric"); } /* Compute the L (= er * grad grad) matrix (the second block) */ auto f2L = form2(_test=M_Qh,_trial=M_Qh, _matrix=M_L); #if 0 //If you want to manage the relative permittivity materials per material, //here is the entry to deal with. for(auto it : M_model.materials() ) { f2L += integrate(_range=markedelements(M_Qh->mesh(),marker(it)), _expr=M_er*inner(gradt(phi), grad(phi))); } #else f2L += integrate(_range=elements(M_Qh->mesh()), _expr=M_er*inner(gradt(phi), grad(phi))); #endif auto f1LQ = form1(_test=M_Qh); for(auto const & it : m_dirichlet_p) { LOG(INFO) << "Applying " << it.second << " on " << it.first << " for "<<M_prefix_22<<"\n"; f2L += on(_range=markedfaces(M_Qh->mesh(),it.first),_element=phi, _expr=it.second, _rhs=f1LQ, _type="elimination_symmetric"); } toc( "[PreconditionerBlockMS] setup done ", FLAGS_v > 0 ); }
void ThermalBlockMinimalVersion::initModel() { gamma_dir=option(_name="gamma_dir").template as<double>(); this->setFunctionSpaces( Pch<1>( loadMesh( _mesh=new Mesh<Simplex<2>> ) ) ); auto mesh = Xh->mesh(); if( Environment::worldComm().isMasterRank() ) { std::cout << "Number of local dof " << Xh->nLocalDof() << "\n"; std::cout << "Number of dof " << Xh->nDof() << "\n"; } auto mu_min = Dmu->element(); auto mu_max = Dmu->element(); mu_min << 0.1 , 0.1 , 0.1 , 0.1 , 0.1 , 0.1 , 0.1 , 0.1 ; mu_max << 10 , 10 , 10 , 10 , 10 , 10 , 10 , 10 ; Dmu->setMin( mu_min ); Dmu->setMax( mu_max ); auto u = Xh->element(); auto v = Xh->element(); auto M = backend()->newMatrix( Xh , Xh ); double mu_min_coeff=0.1; // on boundary north we have u=0 so term from weak dirichlet condition // vanish in the right hand side //rhs auto f0 = form1( _test=Xh ); f0 = integrate( _range=markedfaces( mesh,"south_domain-1" ), _expr= id( v ) ) + integrate( _range=markedfaces( mesh,"south_domain-2" ), _expr= id( v ) ) + integrate( _range=markedfaces( mesh,"south_domain-3" ), _expr= id( v ) ); this->addRhs( { f0, "1" } ); //lhs auto a0 = form2( _trial=Xh, _test=Xh); a0 = integrate( markedelements( mesh, "domain-1" ), gradt( u )*trans( grad( v ) ) ); this->addLhs( { a0 , "1" } ); auto a1 = form2( _trial=Xh, _test=Xh); a1 = integrate( markedelements( mesh, "domain-2" ), gradt( u )*trans( grad( v ) ) ); this->addLhs( { a1 , "mu0" } ); auto a2 = form2( _trial=Xh, _test=Xh); a2 = integrate( markedelements( mesh, "domain-3" ), gradt( u )*trans( grad( v ) ) ); this->addLhs( { a2 , "mu1" } ); auto a3 = form2( _trial=Xh, _test=Xh); a3 = integrate( markedelements( mesh, "domain-4" ), gradt( u )*trans( grad( v ) ) ); this->addLhs( { a3 , "mu2" } ); auto a4 = form2( _trial=Xh, _test=Xh); a4 = integrate( markedelements( mesh, "domain-5" ), gradt( u )*trans( grad( v ) ) ); this->addLhs( { a4 , "mu3" } ); auto a5 = form2( _trial=Xh, _test=Xh); a5 = integrate( markedelements( mesh, "domain-6" ), gradt( u )*trans( grad( v ) ) ); this->addLhs( { a5 , "mu4" } ); auto a6 = form2( _trial=Xh, _test=Xh); a6 = integrate( markedelements( mesh, "domain-7" ), gradt( u )*trans( grad( v ) ) ) +integrate( markedfaces( mesh, "north_domain-7" ), -gradt( u )*vf::N()*id( v ) -grad( u )*vf::N()*idt( v ) ); this->addLhs( { a6 , "mu5" } ); auto a7 = form2( _trial=Xh, _test=Xh); a7 = integrate( markedelements( mesh, "domain-8" ), gradt( u )*trans( grad( v ) ) ) +integrate( markedfaces( mesh, "north_domain-8" ), -gradt( u )*vf::N()*id( v ) -grad( u )*vf::N()*idt( v ) ); this->addLhs( { a7 , "mu6" } ); auto a8 = form2( _trial=Xh, _test=Xh); a8 = integrate( markedelements( mesh, "domain-9" ), gradt( u )*trans( grad( v ) ) ) +integrate( markedfaces( mesh, "north_domain-9" ), -gradt( u )*vf::N()*id( v ) -grad( u )*vf::N()*idt( v ) ); this->addLhs( { a8 , "mu7" } ); auto a9 = form2( _trial=Xh, _test=Xh); a9 = integrate( markedfaces( mesh, "north_domain-7" ),gamma_dir*idt( u )*id( v )/h() ) +integrate( markedfaces( mesh, "north_domain-8" ),gamma_dir*idt( u )*id( v )/h() ) +integrate( markedfaces( mesh, "north_domain-9" ),gamma_dir*idt( u )*id( v )/h() ); this->addLhs( { a9 , "1" } ); form2( Xh, Xh, M ) = integrate( markedelements( mesh, "domain-1" ), gradt( u )*trans( grad( v ) ) ); form2( Xh, Xh, M ) += integrate( markedelements( mesh, "domain-2" ), gradt( u )*trans( grad( v ) ) * mu_min_coeff ); form2( Xh, Xh, M ) += integrate( markedelements( mesh, "domain-3" ), gradt( u )*trans( grad( v ) ) * mu_min_coeff ); form2( Xh, Xh, M ) += integrate( markedelements( mesh, "domain-4" ), gradt( u )*trans( grad( v ) ) * mu_min_coeff ); form2( Xh, Xh, M ) += integrate( markedelements( mesh, "domain-5" ), gradt( u )*trans( grad( v ) ) * mu_min_coeff ); form2( Xh, Xh, M ) += integrate( markedelements( mesh, "domain-6" ), gradt( u )*trans( grad( v ) ) * mu_min_coeff ); form2( Xh, Xh, M ) += integrate( markedelements( mesh, "domain-7" ), gradt( u )*trans( grad( v ) ) * mu_min_coeff ); form2( Xh, Xh, M ) += integrate( markedelements( mesh, "domain-8" ), gradt( u )*trans( grad( v ) ) * mu_min_coeff ); form2( Xh, Xh, M ) += integrate( markedelements( mesh, "domain-9" ), gradt( u )*trans( grad( v ) ) * mu_min_coeff ); form2( Xh, Xh, M ) += integrate( markedfaces( mesh, "north_domain-7" ), -gradt( u )*vf::N()*id( v ) * mu_min_coeff -grad( u )*vf::N()*idt( v ) * mu_min_coeff ); form2( Xh, Xh, M ) += integrate( markedfaces( mesh, "north_domain-8" ), -gradt( u )*vf::N()*id( v ) * mu_min_coeff -grad( u )*vf::N()*idt( v ) * mu_min_coeff ); form2( Xh, Xh, M ) += integrate( markedfaces( mesh, "north_domain-9" ), -gradt( u )*vf::N()*id( v ) * mu_min_coeff -grad( u )*vf::N()*idt( v ) * mu_min_coeff ); form2( Xh, Xh, M ) += integrate( markedfaces( mesh, "north_domain-7" ),gamma_dir*idt( u )*id( v )/h() ); form2( Xh, Xh, M ) += integrate( markedfaces( mesh, "north_domain-8" ),gamma_dir*idt( u )*id( v )/h() ); form2( Xh, Xh, M ) += integrate( markedfaces( mesh, "north_domain-9" ),gamma_dir*idt( u )*id( v )/h() ); this->addEnergyMatrix( M ); }//initModel()
void Beam<nDim,nOrder>::run() { this->changeRepository( boost::format( "doc/manual/solid/%1%/%2%/P%3%/h_%4%/" ) % this->about().appName() % entity_type::name() % nOrder % meshSize ); /* * First we create the mesh */ mesh_ptrtype mesh = createGMSHMesh( _mesh=new mesh_type, _update=MESH_UPDATE_EDGES|MESH_UPDATE_FACES|MESH_CHECK, _desc=domain( _name=( boost::format( "beam-%1%" ) % nDim ).str() , _shape="hypercube", _xmin=0., _xmax=0.351, _ymin=0., _ymax=0.02, _zmin=0., _zmax=0.02, _h=meshSize ) ); // add marker clamped to the mesh mesh->addMarkerName( "clamped",( nDim==2 )?1:19, (nDim==2)?1:2); mesh->addMarkerName( "tip",( nDim==2)?3:27, (nDim==2)?1:2); /* * The function space and some associate elements are then defined */ timers["init"].first.restart(); space_ptrtype Xh = space_type::New( mesh ); Xh->printInfo(); element_type u( Xh, "u" ); element_type v( Xh, "v" ); timers["init"].second = timers["init"].first.elapsed(); /* * Data associated with the simulation */ auto E = doption(_name="E")*pascal; const double nu = doption(_name="nu"); auto mu = E/( 2*( 1+nu ) ); auto lambda = E*nu/( ( 1+nu )*( 1-2*nu ) ); auto density = 1e3; auto gravity = -2*newton/pow<Dim>(meter);//-density*0.05; LOG(INFO) << "lambda = " << lambda << "\n" << "mu = " << mu << "\n" << "gravity= " << gravity << "\n"; /* * Construction of the right hand side * * \f$ f = \int_\Omega g * v \f$ where \f$ g \f$ is a vector * directed in the \f$ y \f$ direction. */ auto F = backend()->newVector( Xh ); F->zero(); timers["assembly"].first.restart(); if ( Dim == 3 ) form1( _test=Xh, _vector=F ) = integrate( elements( mesh ), trans( gravity.value()*oneZ() )*id( v ) ); else form1( _test=Xh, _vector=F ) = integrate( elements( mesh ), trans( gravity.value()*oneY() )*id( v ) ); timers["assembly"].second = timers["assembly"].first.elapsed(); /* * Construction of the left hand side */ auto D = backend()->newMatrix( Xh, Xh ); timers["assembly"].first.restart(); auto deft = sym(gradt(u)); auto def = sym(grad(u)); auto a = form2( _test=Xh, _trial=Xh, _matrix=D ); a = integrate( elements( mesh ), lambda.value()*divt( u )*div( v ) + 2.*mu.value()*trace( trans( deft )*def ) ); if ( M_bctype == 1 ) // weak Dirichlet bc { auto Id = eye<nDim>(); a += integrate( markedfaces( mesh, "clamped" ), - trans( ( 2.*mu.value()*deft+lambda.value()*trace( deft )*Id )*N() )*id( v ) - trans( ( 2.*mu.value()*def+lambda.value()*trace( def )*Id )*N() )*idt( u ) + bcCoeff*std::max(2.*mu.value(),lambda.value())*trans( idt( u ) )*id( v )/hFace() ); } if ( M_bctype == 0 ) a += on( markedfaces( mesh, "clamped" ), u, F, zero<nDim,1>() ); timers["assembly"].second += timers["assembly"].first.elapsed(); backend(_rebuild=true)->solve( _matrix=D, _solution=u, _rhs=F ); v = vf::project( Xh, elements( Xh->mesh() ), P() ); this->exportResults( 0, u, v ); auto i1 = mean( _range=markedfaces( mesh, "tip" ), _expr=idv( u ) ); LOG(INFO) << "deflection: " << i1 << "\n"; } // Beam::run
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