Ctrl+K

fesuper

fesuper#

Purpose

User interface for superelement support.

Syntax

             fesuper('CommandString')
[out,out1] = fesuper('CommandString', ...)
model      = fesuper(model,'CommandString', ... )

Description

Superelements (see section 6.3 for more details) should be declared as SE entries in model.Stack, see fesuper s_ for name restrictions. When using this format, you should specify model as the first argument fesuper so that any modification to the superelement is returned in the modified stack.

F ...#

Get full model from superelement model.

SE=demosdt('demo ubeam'); SE=SE.GetData; % Load full model.
model=fesuper('SESelAsSe',[],SE); % Build SE model.
Node=fesuper('FNode',model); % Get full model nodes.
Elt=fesuper('FElt',model); % Get full model elements.
mfull=fesuper('FSEModel',model); % Get full model.
  • FSEModel generates a full model (with .Node and .Elt fields only) based on all SE. Warning the output erases the input model, so that care must be taken when model is a v_handle. The following command options are available:
    • -Stack to keep the initial stack increased with all SE stacks, to keep material properties and sets.
    • -StackAll to keep all base stack increased with all SE stacks.
    • -SESets to add in the stack element sets corresponding to each SE, under the name _SE_sename.
    • -join to join all element by types in the full model.
  • FElt outputs the full elements of the model.
  • FNode outputs the model full nodes. Command FNodeOptim outputs the nodes actually used in each SE.

Get,Set ...#

Get,set properties from a superelement. Standard superelement fields are detailed in section 6.3.2. get and set commands are obsolete, you should really use direct access to the feplot stack. For example

cf=demosdt('demo cmsSE feplot');
SE1=cf.Stack{'se1'};
SE1=stack_set(SE1,'info','EigOpt',[5 10.1 1e3]);
SE1=fe_reduc('CraigBampton -SE -UseDof',SE1);
cf.Stack{'se1'}=SE1; fecom('curtabStack','SE:se1')

A new command to perform reduction is under development.
mdl=fesuper(mdl,'setTR',name,'fe_reduc command') calls fe_reduc to assemble and reduce the superelement. The command option -drill can be added to the fe_reduc command to consider drilling stiffness in shells. For example mdl=fesuper(mdl, 'SetTR', 'SE1', 'CraigBampton -UseDof -drill');
The modes to be kept in the superelement can be set using mdl=fesuper(mdl, 'setStack', name, 'info', 'EigOpt', EigOptOptions);

Damp#

model=fesuper('Damp',model,'SEname',damp); Defines a modal damping on the superelement SEname. damp can be a scalar zeta0 and defines a global damping ratio on all computed modes. damp can also be a vector [zeta0 f0 zeta1] defining a first damping ratio zeta0 for frequencies lower than f0 Hz and another damping ratio zeta1 for higher frequencies. Note that all modes are computed.

SEDef#

Superelement restitution. These commands are used to handle model partial or full restitution for visualization and recovery handling.

SEDefInit is used to prepare the model for restitution matters. It adds in model.Stack an entry info,SeRestit containing the necessary data for restitution i.e. to perform {q} =[T] {qR}. This aims to limit generic work needed for multiple restitution. Syntax is model=fesuper('SEDefInit',model).

SEDef is used to implement restitution on full model DOFs. Syntax is dfull=fesuper ('SeDef', cf, def)

SEBuildSel#

SEBuildSel is used to perform partial restitution on a model. This command sets feplot to display a restitution mesh and computes the corresponding deformation vectors. The restitution selection is defined as a cell array with rows of the form SeName,EltSel for selection of each superelement. An EltSel entry set to 'groupall' thus displays the full superelement. EltSel can also be an element matrix (usefull to display deformations on a test frame) or even a vector of NodeIds.
To discard a superelement from display, use an empty string for EltSel. By default a superelement not mentioned in the selection is displayed.

After the generation of superelement selections, it is possible to set a global selection on the full mesh by adding an entry with an empty superelement name (see illustration below).

Accepted command options are

  • -nojoin avoids grouping elements of the same topology in a single group.
  • -LinFace can be used to generate selections that only use first order faces (tria3 instead of tria6, ...)
  • -NoOptim is used to skip the restitution optimization phase.
  • -cGL (used in SDT/Rotor) is used in cases with local bases associated with each superelement. In this case, data.cGL is a cell array used to define a local rotation associated with each superelement. Typically, this is equal to data.cGL{jEt}=reshape(mdl.bas(j1,7:15),3,3);.
  • -RotDof (used in SDT/Rotor) large angle DOF

The following example is based on a gimbal model reduced in three superelements: base, gimbal and tele. A partial restitution is proposed.

model=demosdt('demogimbal-reduce')
cf=feplot(model)
def=fe_eig(model,[5 10 1e3 0 1e-5]);


Sel={'gimbal'  'groupall';
'tele'  'InNode{z>=0}';
'base'  ''             };  % base not displayed
fesuper('SEBuildSel',cf,Sel);
cf.def=def;


% Second selection example
Sel={'gimbal'  'groupall';
'tele'  '';
'base'  'groupall'
'',     'InNode{z>=0}'};  % global selection
fesuper('SEBuildSel',cf,Sel);

If you have previously initialized a full restitution with fesuper('SeDefInit',cf), data to optimize partial restitution will be initialized. To obtain a partial restitution of a set of vectors, use data=cf.sel.cna{1};dfull=fesuper('sedef',data,dred).

SE ...#

SEDof is an internal command used to implement proper responses to feutil GetDof commands. It is assumed that the superelement .DOF field is defined prior to setting the information in the model.Stack.

SEMPC is an internal command that need to be documented.

SECon may also need some documentation.

SEAdd ...#

SEAddSEName commands are used to append superelements to a model. With no command option fesuper('SEAdd SEname',model,SE,[matId proId]) appends a new superelement to the model.Elt field (creates a group SE if necessary) and saves the provided SE as a stack entry. [matId proId] can be given as a last argument to define properties associated to added superelement. As a new superelement is generated by default, SEname can be incremented if a superelement already exists with the same name.

The following command options are available

  • -owrite allows overwriting a superelement whose name is already assigned.
  • -name"SEname" can be used instead of letting the superelement name itself in the command, for added robustness.
  • -initcoef can be used in the case where the superelement is already assembled (reduced part, coupling superelement, ...). This allows the definition of a p_superentry of type 2, defining tunable matrix types and coefficients for parametric studies.
  • -newID to assign a new independent EltId to each added superelement. This option makes sure that the assigned EltId is not already used in the full model EltId.

Note that SEname is checked to comply with the superelement naming convention of SDT, (see section 6.3, fesuper s_). If SEname is altered, a warning will tell how and why. The warning can be deactivated by adding ; at the end of the command string.

SE is usually a standard SDT model, with fields .Node, .Elt, .Stack... But this command accepts models defined only from element matrices (needs .K, .Opt and .DOF fields). It can be useful to cleanly import element matrices from other codes for example (see section 4.3.3), or to represent penalized constraints, see fe_mpc.

When defining a superelement, two node and element numbering coexist, one a the superlement level, and one at the global level. To recover a full model at the global level, see FSEModel. To control the global model numbering ranges, ones defines NodeId0 and EltId0. NodeId0 is the lower bound of the range of the superelement implicit nodes (use 1 for no shift). NodeIdEnd is given by NodeIdEnd-NodeId0=max(SE.Node(:,1)). EltId0 is the lower bound of the range of the superelement elements. The EltId range width is equal to the maximum EltId of the superelement.

  • It is possible to define EltId0 to -1 to let fesuper assign an EltId range over the maximum currently used EltId, accouting for the global model.
  • It is possible to define multiple instances of an SE at once (periodic models), see -trans for translation replication and -disk for circular replication. In such case, it is also possible to control the node shift applied between SE by defining a three value series NodeShift NodeId0 EltId0. If only two values are given, NodeShift is defaulted to zero and the two values are interpreted as NodeId0 and EltId0.

SEAdd -unique NodeId0 EltId0 SEname is used to add a single superelement and to give its ranges of implicit nodes and elements.

SEAdd -trans nrep tx ty tz <NodeShift> NodeId0 EltId0 SEname is used to repeat the model nrep times with a translation step (tx ty tz). NodeId0 is the lower bound of the range of the first superelement implicit nodes. The range width is equal to the maximum NodeId of the superelement. The ranges of implicit nodes for repeated superelements are translated so that there is no overlap. To obtain overlap, you must specify NodeShift NodeId0 EltId0, then there is a NodeId range overlap of NodeShift nodes. This is used to obtain superelement intersections that are not void and NodeShift is the number of intersection nodes between 2 superelements. EltId0 is the lower bound of the EltId range of elements of the first superelement. There is no EltId range overlap. Option -basval can be used as a starting value for the BasId of superelements.
For example

model=femesh('testhexa8');
model=feutil('renumber',model,model.Node(:,1)*10);
mo1=fesuper('SEAdd -trans 5 0 0 1 10000 10000 cube',[],model)
feplot(mo1)

SEAdd -disk <NodeShift> NodeId0 EltId0 SEName is used to repeat a sector model in cyclic symmetry. It is assumed that the symmetry case entry exists in the model (see fe_cyclic Build).

In all these cases, matrix of nodes of the superelement is sorted by NodeId before it is added to the stack of the model (so that SE.Node(end,1)==max(SE.Node(:,1)).

SEAssemble ...#

Command fesuper('SEAssemble',model) is used to assemble matrices of superelements that are used in model. A basis reduction from superelement Case.T (Interface DofSet is ignored) is performed.

SEDispatch ...#

Command fesuper('SEDispatch',model) is used to dispatch constraints (mpc, rbe3, rigid elements, ...) of the global model in the related superelements, and create DofSet on the interface DOFs.

Rigid elements in model.Elt are distributed to the superelements (may be duplicated) that contain the slave node. The master node of the rigid element must be present in the superelement node matrix, even if it is unused by its elements (SESelAsSE called with selections automatically adds those nodes to the superelements).

Other constraints (mpc, rbe3, FixDof) are copied to superelement if all constraint DOFs are within the superelement. Constraints that span multiple superelements are not dispatched. All constraints remain declared in the main model. Parameters (par entries in Case) are also dispatched if the selection in the superelement is not empty.

Finally a DofSet (identity def matrix) is defined on superelement DOFs that are active in the global model and shared by another superelement. Those DofSet are stored in the 'Interface' entry of each superelement stack.

SEDofShow#

Command fesuper('SeDofShow',cf'tag); localizes nodes supporting DOF of superelements with mathing name based on tag and adds the SE names in an feplot display using cf. tag can be omitted in which case all SE are treated. tag can be replaced by a input structure with acceptable fields

  • .tag provides the tag defined earlier.
  • .evF provides a function handle to compute custom SE name anchor coordinates from SE.Node(:,5:7). Default uses @mean.
  • .sel provides a custom feplot selection command to update display. Default is set to reset-linface, use an empty field not to alter the current feplot selection.

SEInitCoef ...#

Command fesuper('SEInitCoef',model) can be used to initialize p_super properties in model for used superelements. The full syntax allows choosing the type and a subselection of SE, [model,pro]=fesuper('SEInitCoeftyp',model'sel);. typ can take values 1 or 2 to define the chosen p_super type (the default is type 2). sel can either be a FindElt string providing SE elements only or a index vector or SE elements in model.Elt. The outputs are model with additional pro Stack entries, and pro the list of treated ProId.

SEIntNode ...#

Command fesuper('SEIntNode',model) can be used to define explicitly superelement interface nodes, taking into account local basis.

SESelAsSE ...#

Selection as superelement. Command fesuper('SESelAsSE', model, Sel) is used to split a model in some superelement models, or to build a model from sub models taken as superelements.
Sel can be a FindElt string selector, or a model data structure.
If Sel is a FindElt string selector, the elements corresponding to the selection are removed from model, and then added as a superelement model. The implicit NodeId of the superelement are the same as the former NodeId in model. Warning: the selection by element group is not available due to internal renumbering operations performed in this task.
If Sel is a model, it is simply added to model as a superelement.
Sel can also be a cell array of mixed types (FindElt string selector or model data structure): it is the same as calling sequentially a SESelAsSE command for each element of the cell array (so avoid using group based selection for example, because after the first selection model.Elt may change).
You can give a name to each superelement in the second column of Sel
{Selection_or_model,SEname; ...}. If name is not given (only one column in Sel), default seID is used.
By default, superelements Mat/ProId are generated and incremented from 1001. It is possible to specify the MatId and/or ProId of the superelements created by adding a third column to Sel, with either a scalar value to apply to MatId and ProId or a line vector under the format [MatId ProId]. E.g. Sel={Selection,SEname,[1001 1001];...}. When the third column is left empty for certain lines, the default behavior is applied for these lines only.
Master nodes of the global model rigid elements are added to the superelements that contain corresponding slave nodes. By default, model properties are forwarded to the superelement fields, that is to say il, pl, stack entry types pro, mat, bas, set, and possible stack entries info,Rayleigh and info,Omega.
Superelement addtion is realized with command fesuper SEAdd, additional command options provided in command SeSelAsSe will be forwarded to SEAdd. E.g. one can use directly token -newID to generate clean EltId for added superelements.

The following example Run divides the d_cms model into 2 sub superelement models.

  • The command option -dispatch can be used to dispatch constraints (rigid elements, mpc, rbe3 ...) of the global model in the related superelements and create DofSet on the interface DOFs. It is the same as calling the fesuper SEDispatch command after SESelAsSE without command option.
  • Command option -noPropFwd can be used not to forward some model data to the superelement stack (older version compatibility). If used, stack entries of type, pro, mat, bas, set, and possible stack entries info,Rayleigh, info,Omega will not be forwarded to the superelement model.

SERemove#

model=fesuper('SERemove',model,'name') searches superelement name in the model and removes it from Stack and element matrix.

SERenumber#

SE=fesuper('renumber',model,'name') searches superelement name in the model stack and renumbers based on the entry in the SE element group. If name refers to multiple superelements, you should provide the row number in model.Elt.

s_#

Superelement name coding operations. To allow storage in an element row, names must be 8 characters or less, combining letters a...z and numbers 0...9. They are taken to be case insensitive. For proper use, superelement names should not contain the chain back, and should not start with 0.

num=fesuper('s_name') returns the number coding the superelement name. name=fesuper('s_',num) decodes the number. elt=fesuper('s_name',model) extracts elements associated with a given superelement.

See also

fe_super, upcom, section 4.3.3,  section 6.3

Contents