PDF|
Contents
Functions
Index
PDF |
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. 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. Superelement should be short lower case names to allow name encoding.
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 properties from a superelement. Standard superelement fields are detailed in section 6.3.2. get and set commands are obsolete, you shoud 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 modifier -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);
Superelement restitutions. These commands are used to handle model partial or full restitutions for visualzation and recovery handling.
SEDefInit is used to prepare the model for restitution matters. It adds in model. Stack a field info,SeRestit containing the necessary data for restitution i.e. to perform {q} =[T] {qR}. This aims to limit generic work needed for multiple restitutions. Syntax is model=fesuper('SEDefInit',model).
SEDef is used to implement restitution on full model DOFs. Syntax is dfull=fesuper ('SeDef', cf, def)
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 has to be defined following the format {seName EltSel ; ...} . EltSel is a string containing element selectors. Such format allows the restitution to be performed on parts of superelements. To display a full superelement the EltSel entry must be set as 'groupall'. To discard a superelement from display, EltSel must be set to an empty string. By default a superelement not mentionned in the selection is displayed. Eventually it is possible to set a global selection on the full mesh. The last selection entry must then start with a blank seName : '', EltSel.
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);
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 needs some documentation.
SEAdd SEName commands are used to append superelements to a model. With no command modifier fesuper('SEAdd name',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.
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.1.8).
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. The NodeId range width is equal to the maximum NodeId of the superelement. 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 <NodeShift> NodeId0 EltId0 SEName is used to repeat the model with a given translation step (nrep). NodeIdO 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 excepted if NodeShift argument is given (then there is a NodeId range overlap of NodeShift nodes. It can be useful if the repeated superelement intersections are not void: then NodeShift can be 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.
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)).
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.
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 moved to superelement if all constraint DOFs are within the superelement. Constraints that span multiple superelements are not dispatched.
A unit DofSet (identity def matrix, same DOFs) is defined in superelements that contain all DOFs of the global model DofSet.
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.
The command fesuper('SEIntNode',model) can be used to define explicitly superelement interface nodes, taking into account local basis.
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.
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.
Master nodes of the global model rigid elements are added to the superelements that contain corresponding slave nodes.
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}'});
The command modifier -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 modifier.
model=fesuper('SERemove',model,'name') searches superelement name in the model and removes it from Stack and element matrix.
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.
See also
fe_super, upcom, section 4.1.8, section 6.3
©1991-2008 by SDTools
