Name

gf_model_set — Modify a model object.

Calling Sequence

gf_model_set(md,'variable', vec U[, int niter])
gf_model_set(md,'clear')
gf_model_set(md,'add fem variable', string name, mesh_fem mf[, int niter])
gf_model_set(md,'add variable' string name, int size[, int niter])
gf_model_set(md,'resize variable' string name, int size)
gf_model_set(md,'add fem data', string name, mesh_fem mf[, int niter])
gf_model_set(md,'add initialized fem data', string name, mesh_fem mf, vec V)
gf_model_set(md,'add data', string name, mesh_fem mf, vec V)
gf_model_set(md,'add initialized data', string name, vec V)
gf_model_set(md,'add multiplier', string name, mesh_fem mf, mesh_im mim, string primalname, int region[, int niter])
gf_model_set(md,'to variables', vec V)
ind_brick=gf_model_set(md,'add Laplacian brick', mesh_im mim, string varname[, int region])
ind_brick=gf_model_set(md,'add generic elliptic brick', mesh_im mim, string varname[, int region])
ind_brick=gf_model_set(md,'add source term brick', mesh_im mim, string varname, string dataname[, int region[, string directdataname ]])
ind_brick=gf_model_set(md,'add normal source term brick', mesh_im mim, string varname, string dataname, int region)
ind_brick=gf_model_set(md,'add Dirichlet condition with multiplier', mesh_im mim, string varname, mult_description, int region[, string dataname ])
ind_brick=gf_model_set(md,'add Dirichlet condition with penalization', mesh_im mim, string varname, scalar coeff, int region[, string dataname ])
ind_brick=gf_model_set(md,'add generalized Dirichlet condition with multiplier', mesh_im mim, string varname, mult_description, int region, string dataname, string Hname)
ind_brick=gf_model_set(md,'add generalized Dirichlet condition with penalization', mesh_im mim, string varname, scalar coeff, int region, string dataname, string Hname)
gf_model_set(md,'change penalization coeff', int ind_brick, scalar coeff)
ind_brick=gf_model_set(md,'add Helmholtz brick', mesh_im mim, string varname, string dataname[, int region])
ind_brick=gf_model_set(md,'add Fourier Robin brick', mesh_im mim, string varname[, string dataname, int region)
ind_brick=gf_model_set(md,'add constraint with penalization',  string varname, scalar coeff, mat B, vec L)
ind_brick=gf_model_set(md,'add constraint with multipliers,  string varname, string multname, mat B, vec L)
ind_brick=gf_model_set(md,'add explicit matrix', string varname1, string varname2, mat B[, int issymmetric[, int iscoercive]])
ind_brick=gf_model_set(md,'add explicit rhs', string varname, vec L)
gf_model_set(md,'set private matrix',  int indbrick, mat B)
gf_model_set(md,'set private rhs',  int indbrick, vec L)
gf_model_set(md,'disable bricks',  ivec indbricks)
gf_model_set(md,'unable bricks',  ivec indbricks)
ind_brick=gf_model_set(md,'add isotropic linearized elasticity brick', mesh_im mim, string varname, string dataname_lambda, string dataname_mu[, int region])
ind_brick=gf_model_set(md,'add linear incompressibility brick', mesh_im mim, string varname, string multname_pressure[, int region[, string dataname_coeff]])
ind_brick=gf_model_set(md,'add mass brick', mesh_im mim, string varname[, string dataname_rho[, int region]])
ind_brick=gf_model_set(md,'add basic d on dt brick', mesh_im mim, string varnameU,  string dataname_dt[, string dataname_rho[, int region]])
ind_brick=gf_model_set(md,'add basic d2 on dt2 brick', mesh_im mim, string varnameU,  string varnameV, string dataname_dt, string dataname_alpha[, string dataname_rho[, int region]])
gf_model_set(md,'add theta method dispatcher', ivec bricks_indices, string theta)
gf_model_set(md,'add midpoint dispatcher', ivec bricks_indices)
gf_model_set(md,'velocity update for order two theta method',  string varnameU,  string datanameV, string dataname_dt, string dataname_theta)
gf_model_set(md,'velocity update for Newmark scheme',  int id2dt2_brick, string varnameU,  string datanameV, string dataname_dt, string dataname_twobeta,  string dataname_gamma)
gf_model_set(md,'first iter')
gf_model_set(md,'next iter')
ind_brick=gf_model_set(md,'add basic contact brick', string varname_u, string multname_n[, string multname_t], string dataname_r, mat BN[, mat BT, string dataname_friction_coeff][, string dataname_gap[, string dataname_alpha[, int symmetrized]]])
gf_model_set(md,'contact brick set BN', int indbrick, mat BN)
gf_model_set(md,'contact brick set BT', int indbrick, mat BT)
ind_brick=gf_model_set(md, 'add contact with rigid obstacle brick', mesh_im mim, string varname_u, string multname_n[, string multname_t], string dataname_r[, string dataname_friction_coeff], int region, string obstacle, [,  int symmetrized])
    

Description

  • gf_model_set(mds,'clear') Clear the model.

  • gf_model_set(mds,'add fem variable', string name, MeshFem mf[, int niter]) Add a variable to the model linked to a MeshFem. name is the variable name and niter is the optional number of copy of the variable for time integration schemes.

  • gf_model_set(mds,'add variable', string name, int size[, int niter]) Add a variable to the model of constant size. name is the variable name and niter is the optional number of copy of the variable for time integration schemes.

  • gf_model_set(md,'resize variable', string name, int size) : Resize a fixed size variable of the model. name is the variable name, size is the new fixed size.

  • gf_model_set(mds,'add multiplier', string name, MeshFem mf, string primalname[, int niter]) Add a particular variable linked to a fem being a multiplier with respect to a primal variable. The dof will be filtered with the gmm::range_basis function applied on the terms of the model which link the multiplier and the primal variable. This in order to retain only linearly independant constraints on the primal variable. Optimized for boundary multipliers. niter is the number of version of the data stored, for time integration schemes.

  • gf_model_set(mds,'add fem data', string name, MeshFem mf[, int qdim, int niter]) Add a data to the model linked to a MeshFem. name is the data name, qdim is the optional dimension of the data over the MeshFem and niter is the optional number of copy of the data for time integration schemes.

  • gf_model_set(mds,'add initialized fem data', string name, MeshFem mf, vec V) Add a data to the model linked to a MeshFem. name is the data name. The data is initiakized with V. The data can be a scalar or vector field.

  • gf_model_set(mds,'add data', string name, int size[, int niter]) Add a data to the model of constant size. name is the data name and niter is the optional number of copy of the data for time integration schemes.

  • gf_model_set(mds,'add initialized data', string name, V) Add a fixed size data to the model linked to a MeshFem. name is the data name, V is the value of the data.

  • gf_model_set(mds,'variable', string name, vec V[, int niter]) Set the value of a variable or data.

  • gf_model_set(mds,'to variables', vec V) Set the value of the variables of the model with the vector V. Typically, the vector V results of the solve of the tangent linear system (usefull to solve your problem with you own solver).

  • ind = gf_model_set(mds,'add Laplacian brick', mesh_im mim, string varname[, int region]) add a Laplacian term to the model relatively to the variable varname. If this is a vector valued variable, the Laplacian term is added componentwise. region is an optional mesh region on which the term is added. If it is not specified, it is added on the whole mesh.

  • ind = gf_model_set(mds,'add generic elliptic brick', mesh_im mim, string varname, string dataname[, int region]) add a generic elliptic term to the model relatively to the variable varname. The shape of the elliptic term depends both on the variable and the data. This corresponds to a term where a is the data and u the variable. The data can be a scalar, a matrix or an order four tensor. The variable can be vector valued or not. If the data is a scalar or a matrix and the variable is vector valued then the term is added componentwise. An order four tensor data is allowed for vector valued variable only. The data can be constant or describbed on a fem. Of course, when the data is a tensor describe on a finite element method (a tensor field) the data can be a huge vector. The components of the matrix/tensor have to be stored with the fortran order (columnwise) in the data vector (compatibility with blas). The symmetry of the given matrix/tensor is not verified (but assumed). If this is a vector valued variable, the Laplacian term is added componentwise. region is an optional mesh region on which the term is added. If it is not specified, it is added on the whole mesh.

  • ind = gf_model_set(mds,'add source term brick', mesh_im mim, string varname, string dataname[, int region]) add a source term to the model relatively to the variable varname. The source term is represented by the data dataname which could be constant or described on a fem. region is an optional mesh region on which the term is added. An additional optional data directdataname can be provided. The corresponding data vector will be directly added to the right hand side without assembly.

  • ind = gf_model_set(mds,'add normal source term brick', mesh_im mim, string varname, string dataname[, int region]) add a source term on the variable varname on a boundary region. The source term is represented by the data dataname which could be constant or described on a fem. A scalar product with the outward normal unit vector to the boundary is performed. The main aim of this brick is to represent a Neumann condition with a vector data without performing the scalar product with the normal as a pre-processing.

  • ind = gf_model_set(mds,'add Dirichlet condition with multipliers', mesh_im mim, string varname, mult_description, int region[, string dataname]) Add a Dirichlet condition on the variable varname and the mesh region region. This region should be a boundary. The Dirichlet condition is prescribed with a multiplier variable described by mult_description. If mult_description is a string this is assumed to be the variable name correpsonding to the multiplier (which should be first declared as a multiplier variable on the mesh region in the model). If it is a finite element method (mesh_fem object) then a multiplier variable will be added to the model and build on this finite element method (it will be restricted to the mesh region region and eventually some conflicting dofs with some other multiplier variables will be suppressed). If it is an integer, then a multiplier variable will be added to the model and build on a classical finite element of degree that integer. dataname is the optional right hand side of the Dirichlet condition. It could be constant or described on a fem; scalar or vector valued, depending on the variable on which the Dirichlet condition is prescribed. Return the brick index in the model.

  • ind = gf_model_set(mds,'add Dirichlet condition with penalization', mesh_im mim, string varname, scalar coeff, int region[, string dataname]) Add a Dirichlet condition on the variable varname and the mesh region region. This region should be a boundary. The Dirichlet condition is prescribed with penalization. The penalization coefficient is intially coeff and will be added to the data of the model. dataname is the optional right hand side of the Dirichlet condition. It could be constant or described on a fem; scalar or vector valued, depending on the variable on which the Dirichlet condition is prescribed. Return the brick index in the model.

  • ind_brick=gf_model_set(md,'add generalized Dirichlet condition with multiplier', mesh_im mim, string varname, string multname | mesh_fem mf_mult | int degree, int region, string dataname, string Hname) : Add a Dirichlet condition on the variable varname and the mesh region region. This version is for vector field. It prescribes a condition $Hu = r$ where H is a matrix field. The region should be a boundary. The Dirichlet condition is prescribed with a multiplier variable which can be either directly given by multname (should be first declared as a multiplier variable on the mesh region in the model) or added by the function and buld on the given finite element method mf_mult (it will be restricted to the mesh region region and eventually some conflicting dofs with some other multiplier variables will be suppressed) or added by the function and build on a standard finite element method of degree degree. dataname is the optional right hand side of the Dirichlet condition. It could be constant or described on a fem; scalar or vector valued, depending on the variable on which the Dirichlet condition is prescribed. Hname is the data corresponding to the matrix field H. It has to be a constant matrix or described on a scalar fem. Return the brick index in the model.

  • ind_brick=gf_model_set(md,'add generalized Dirichlet condition with penalization', mesh_im mim, string varname, scalar coeff, int region, string dataname, string Hname) : Add a Dirichlet condition on the variable varname and the mesh region region. This version is for vector field. It prescribes a condition $Hu = r$ where H is a matrix field. The region should be a boundary. The Dirichlet condition is prescribed with penalization. The penalization coefficient is intially coeff and will be added to the data of the model. dataname is the optional right hand side of the Dirichlet condition. It could be constant or described on a fem; scalar or vector valued, depending on the variable on which the Dirichlet condition is prescribed. Hname is the data corresponding to the matrix field H. It has to be a constant matrix or described on a scalar fem. Return the brick index in the model.

  • gf_model_set(mds,'change penalization coeff', int ind_brick, scalar coeff) Change the penalization coefficient of a Dirichlet condition with penalization brick. If the brick is not of this kind, this function has an undefined behavior.

  • ind = gf_model_set(mds,'add Helmholtz brick', mesh_im mim, string varname, string dataname[, int region]) add a Helmholtz term to the model relatively to the variable varname. dataname should contain the wave number. region is an optional mesh region on which the term is added. If it is not specified, it is added on the whole mesh.

  • ind = gf_model_set(mds,'add Fourier Robin brick', mesh_im mim, string varname, string dataname, int region) add a Fourier-Robin term to the model relatively to the variable varname. this corresponds to a weak term of the form . dataname should contain the parameter q of the Fourier-Robin condition. region is the mesh region on which the term is added.

  • ind = gf_model_set(mds,'add constraint with multipliers', string varname, string multname, mat B, vec L) Add an additional explicit constraint on the variable varname thank to a multiplier multname peviously added to the model (should be a fixed size variable). The constraint is BU=L with B being a rectangular sparse matrix. It is possible to change the constraint at any time whith the methods gf_model_set(mds,'set private matrix') and gf_model_set(mds,'set private rhs')

  • ind = gf_model_set(mds,'add constraint with penalization', string varname, scalar coeff, mat B, vec L) Add an additional explicit penalized constraint on the variable varname. The constraint is BU=L with B being a rectangular sparse matrix. Be aware that B should not contain a palin row, otherwise the whole tangent matrix will be plain. It is possible to change the constraint at any time whith the methods gf_model_set(mds,'set private matrix') and gf_model_set(mds,'set private rhs'). The method gf_model_set(mds,'change penalization coeff') can be used.

  • ind = gf_model_set(mds,'add explicit matrix', string varname1, string varname2, mat B[, int issymmetric[, int iscoercive]]) Add a brick reprenting an explicit matrix to be added to the tangent linear system relatively to the variables 'varname1' and 'varname2'. The given matrix should have has many rows as the dimension of 'varname1' and as many columns as the dimension of 'varname2'. If the two variables are different and if issymmetric is set to 1 then the transpose of the matrix is also added to the tangent system (default is 0). set iscoercive to 1 if the term does not affect the coercivity of the tangent system (default is 0). The matrix can be changed by the command gf_model_set(mds,'set private matrix').

  • ind = gf_model_set(mds,'add explicit rhs', string varname, vec L) Add a brick reprenting an explicit right hand side to be added to the right hand side of the tangent linear system relatively to the variable 'varname'. The given rhs should have the same size than the dimension of varname. The rhs can be changed by the command gf_model_set(mds,'set private rhs').

  • gf_model_set(mds,'set private matrix', int indbrick, mat B) For some specific bricks having an internal sparse matrix (explicit bricks: 'constraint brick' and 'explicit matrix brick'), set this matrix.

  • gf_model_set(mds,'set private rhs', int indbrick, vec B) For some specific bricks having an internal right hand side vector (explicit bricks: 'constraint brick' and 'explicit rhs brick'), set this rhs.

  • ind = gf_model_set(mds,'add isotropic linearized elasticity brick', mesh_im mim, string varname, string dataname_lambda, string dataname_mu[, int region]) add an isotropic linearized elasticity term to the model relatively to the variable varname. dataname_lambda and dataname_mu should contain the Lamé coefficients. region is an optional mesh region on which the term is added. If it is not specified, it is added on the whole mesh.

  • ind = gf_model_set(mds,'add linear incompressibility brick', mesh_im mim, string varname, string multname_pressure[, int region[, string dataname_coeff]]) add an linear incompressibility condition on variable. multname_pressure is a variable which represent the pressure. Be aware that an inf-sup condition between the finite element method describing the rpressure and the primal variable has to be satisfied. region is an optional mesh region on which the term is added. If it is not specified, it is added on the whole mesh. dataname_coeff is an optional penalization coefficient for nearly incompressible elasticity for instance. In this case, it is the inverse of the Lamé coefficient lambda.

  • ind = gf_model_set(mds,'add mass brick', mesh_im mim, string varname[, string dataname_rho[, int region]]) add mass term to the model relatively to the variable varname. If specified, the data dataname_rho should contain the density (1 if omitted). region is an optional mesh region on which the term is added. If it is not specified, it is added on the whole mesh.

  • ind = gf_model_set(mds,'add basic d on dt brick', mesh_im mim, string varnameU, string dataname_dt[, string dataname_rho[, int region]]) Add the standard discretization of a first order time derivative on varnameU. The parameter rho is the density which could be omitted (the defaul value is 1). This brick should be used in addition to a time dispatcher for the other terms.

  • ind = gf_model_set(mds,'add basic d2 on dt2 brick', mesh_im mim, string varnameU, string datanameV, string dataname_dt, string dataname_alpha,[, string dataname_rho[, int region]]) Add the standard discretization of a second order time derivative on varnameU. datanameV is a data represented on the same finite element method as U which represents the time derivative of U. The parameter rho is the density which could be omitted (the defaul value is 1). This brick should be used in addition to a time dispatcher for the other terms. The time derivative v of the variable u is preferably computed as a post-traitement which depends on each scheme. The parameter dataname_alpha depends on the time integration scheme.

  • gf_model_set(mds,'add theta method dispatcher', vec bricks_indices, string theta) Add a theta-method time dispatcher to a list of bricks. For instance, a matrix term K will be replaced by .

  • gf_model_set(mds,'add midpoint dispatcher', vec bricks_indices) Add a midpoint time dispatcher to a list of bricks. For instance, a nonlinear term K(U) will be replaced by .

  • gf_model_set(mds,'velocity update for order two theta method', string varnameU, string datanameV, string dataname_dt, string dataname_theta) Function which udpate the velocity vn+1 after the computation of the displacement un+1 and before the next iteration. Specific for theta-method and when the velocity is included in the data of the model.

  • gf_model_set(mds,'velocity update for Newmark scheme', int id2dt2_brick, string varnameU, string datanameV, string dataname_dt, string dataname_twobeta, string dataname_alpha) Function which udpate the velocity vn+1 after the computation of the displacement un+1 and before the next iteration. Specific for Newmark scheme and when the velocity is included in the data of the model. This version inverts the mass matrix by a conjugate gradient.

  • gf_model_set(mds,'disable bricks', vec bricks_indices) Disable a brick (the brick will no longer participate to the building of the tangent linear system).

  • gf_model_set(mds,'unable bricks', vec bricks_indices) Unable a disabled brick.

  • ind = gf_model_set(mds,'first iter') To be executed before the first iteration of a time integration scheme

  • ind = gf_model_set(mds,'next iter') To be executed at the end of each iteration of a time integration scheme.

  • ind_brick=gf_model_set(md,'add basic contact brick', string varname_u, string multname_n[, string multname_t], string dataname_r, mat BN[, mat BT, string dataname_friction_coeff][, string dataname_gap[, string dataname_alpha[, int symmetrized]]]) : Add a contact with or without friction brick to the model. If U is the vector of degrees of freedom on which the unilateral constraint is applied, the matrix BN have to be such that this constraint is defined by B_N U \le 0. A friction condition can be considered by adding the three parameters multname_t, BT and dataname_friction_coeff. In this case, the tangential displacement is B_T U and the matrix BT should have as many rows as BN multiplied by d-1 where d is the domain dimension. In this case also, dataname_friction_coeff is a data which represents the coefficient of friction. It can be a scalar or a vector representing a value on each contact condition. The unilateral constraint is prescribed thank to a multiplier multname_n whose dimension should be equal to the number of rows of BN. If a friction condition is added, it is prescribed with a multiplier multname_t whose dimension should be equal to the number of rows of BT. The augmentation parameter r should be chosen in a range of acceptabe values (see Getfem user documentation). dataname_gap is an optional parameter representing the initial gap. It can be a single value or a vector of value. dataname_alpha is an optional homogenization parameter for the augmentation parameter (see Getfem user documentation). The parameter symmetrized indicates that the symmetry of the tangent matrix will be kept or not (except for the part representing the coupling between contact and friction which cannot be symmetrized).

  • gf_model_set(md,'contact brick set BN', int indbrick, mat BN) : Can be used to set the BN matrix of a basic contact/friction brick.

  • gf_model_set(md,'contact brick set BT', int indbrick, mat BT) : Can be used to set the BT matrix of a basic contact with friction brick.

  • ind_brick=gf_model_set(md, 'add contact with rigid obstacle brick', mesh_im mim, string varname_u, string multname_n[, string multname_t], string dataname_r[, string dataname_friction_coeff], int region, string obstacle, [, int symmetrized]) : Add a contact with or without friction condition with a rigid obstacle to the model. The condition is applied on the variable varname_u on the boundary corresponding to region. The rigid obstacle should be described with the string `obstacle` being a signed distance to the obstacle. This string should be an expression where the coordinates are 'x', 'y' in 2D and 'x', 'y', 'z' in 3D. For instance, if the rigid obstacle correspond to z <= 0, the corresponding signed distance will be simply 'z'. multname_n should be a fixed size variable whose size is the number of degrees of freedom on boundary region. It represent the contact equivalent nodal forces. In order to add a friction condition one has to add the multname_t and dataname_friction_coeff parameters. multname_t should be a fixed size variable whose size is the number of degrees of freedom on boundary region multiplied by d-1 where d is the domain dimension. It represent the friction equivalent nodal forces. The augmentation parameter r should be chosen in a range of acceptabe values (close to the Young modulus of the elastic body, see Getfem user documentation). dataname_friction_coeff is the friction coefficient. It could be a scalar or a vector of values representing the friction coefficient on each contact node. The parameter symmetrized indicates that the symmetry of the tangent matrix will be kept or not. Basically, this brick compute the matrix BN and the vectors gap and alpha and call the basic contact brick.

See Also

gf_model_get, gf_model

Authors

Y. Collette