Contents     Functions         Previous Next     PDF Index

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.

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

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.cna1;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

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.

SEAdd -unique NodeId0 EltId0 SEname is used to add a single superelement and to give its ranges of implicit nodes and elements. 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.

SEAdd -trans nrep tx ty tz 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 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 ...

The 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 ...

The 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.

SEIntNode ...

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

SESelAsSE ...

Selection as superelement. The 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.

Following example divides the d_cms model into 2 sub superelement models.

mdl=demosdt('demo cms');
model=fesuper('SESelAsSE',mdl, ...
  {'WithNode{x>0|z>0}';'WithNode{x<0|z<0}'});

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


©1991-2017 by SDTools
Previous Up Next