Contents     Functions     Index     Previous Next     PDF

fevisco



Purpose

User interface function for support of viscoelastic materials

This function is part of the viscoelastic tools.

Syntax
 out = fevisco('command',model);
Description

The solid and fluid models typically used for viscoelastic studies are described in section 6.6, where sample applications are treated.

AddMat,Par2Visc

model=fevisco('addmat MatId',model,'NameForMatId',Material); is used to properly append a viscoelastic material with the given MatId to the model. The tag NameForMatId should match that of a parameter in zCoef. fevisco('Par2Visc',cf) checks the existence of viscoelastic materials associated with matrices and modifies the zCoefFcn entries accordingly
cf=fevisco('testplateLoadMV feplot');
% define material with a unit conversion
mat=m_visco('convert INSI',m_visco('database Soundcoat-DYAD609'));
%                 MatId for original, name of parameter
cf.mdl = fevisco('addmat 101',cf.mdl,'Constrained 101',mat);
fevisco('par2visc',cf);cf.Stack{'zCoef'}
cf.Stack{'info','Freq'}=[500:10:4000]';
cf.Stack{'info','Range'}=[10 20]';
fe2xf('zcoef',cf)

Fluid [merge,matrix,makereduced, ...]

These commands are meant to allow the generation of a coupled fluid/structure model based on a reduced model used for viscoelastic structure predictions (result of a fe2xf direct command for example).

A complete example is treated in section 6.11.1. The steps are

Feplot

fevisco('feplotEnerK','matid1001','matid1 2 3'); displays the strain energy of the viscoelastic part of the structure (first selection here MatId 1001) as one object and the rest of the structure (element selection in third argument) as a wire-frame.

MakeModel [Matid i]

A parametric model is described by a type 1 superelement as detailed in section 6.9.2.

The MakeModel command generates this model based on a type 3 superelement where parameters are set (see upcom ParStack commands, one then generates a model for parametric studies) or where viscoelastic materials have been properly declared using fevisco addmat commands (note that you can start with parameters and use the par2visc command to declare those parameters to correspond to viscoelastic materials, see section 6.9.1). You can also parameterize elastic materials using MakeModel MatId i where the additional elastic materials are given by i. The example given in section 6.10.3, uses commands
 fevisco('testplate up');cf=feplot;Up=cf.mdl;% This is a simple test case
 Up=stack_rm(Up,'mat');
 Up = fevisco('addmat 101',Up,'First area','ISD112 (1993)');
 Up = fevisco('addmat 103',Up,'Second area','ISD112 (1993)');
 MV = fevisco('makemodel matid 101 103',Up);  
If you have a reduced basis in def, MVR = fevisco('makemodel matid 101 103',Up,def); is used to generate a reduced model. See section 6.10.3.

The resulting data structure MV contains all the stack entries needed for viscoelastic response computations (see section 6.9.2) : parameters defined in the case stack and viscoelastic materials defined as mat entries and as elastic materials in MV.pl (this is needed to define the reference modulus value, the selection of a reference E or G is based on the content of mat.nomo.

Range[Vect,Face,Grid,CubeEdge,rand]

Range commands generate standard experiments (series of design points) that can then be used to evaluate model properties at these points. These are defined based on the upcom parameter matrix obtained with upcom('parcoefpar') where each row describes the acceptable range of a parameter
    [type cur min max vtype]
type is not used here and vtype==2 indicates a logarithmic variation. The output is an hcube data structure with fields


.val matrix where each rows gives values of all parameters at a particular design point
.param indices of the parameters that actually change during the experiment
.edge connectivity matrix used to define lines connecting different design points of the experiment


Figure 9.3: Positions of exact mode evaluations in parameter space. a) Hypercube face center. b) Classical 2NP factorial plan.


fevisco('Rangeface 1 2',par,indp) generates a design points at the orthogonal projection of the nominal point (given by par(:,2)) on the lower and/or upper faces defined by the parameter range defined by par(:,3:4). ParFace 1 only generates points of faces with minimum parameter values. Face 0 is the nominal point. The optional third argument indp is used to enforce variations on a subset of parameters.

fevisco('Rangegrid opt',Up,indp) generates a uniform grid by dividing the range of each parameter in opt points. When used for selected parameters by giving indp, the unused parameters are set to their nominal value.

fevisco('Rangegrid opt edge elevel',Up,indp) generates a uniform grid by dividing the range of each parameter in opt points. One then only retains points that are on an edge level elevel defined by the fact that elevel parameters are equal to their minimal or maximal value.

fevisco('Rangecubeedge opt',Up,indp) retains the one dimensional edges of the hypercube defined by parameters selected in indp.

fevisco('RangeRandopt',Up,indp) creates a random experiment on indp with opt design points.

Samples calls are as follows
 hcube=fevisco('RangeVect 4',[0 10])
 par=[0 0 -2 1 2;0 -1 -2 1 2;0 1 .1 2 0];
 % Uniform 3 by 4 grid on parameters 2 and 3
 hcube=fevisco('RangeGrid 3 4',par,[2 3]);hcube.val
 % Face centers on all parameters
 hcube=fevisco('RangeFace 1 2',par);hcube.val

MakeSandwich layers

Tools for the generation of multi-layer sandwich models.
 fevisco('makesandwich (layer generation)',FEnode,FEel0,treated,MAPN);
For each layer, the makesandwich command specifies The supporting model can be specified by its nodes and elements as shown above or using a model data structure. Treated is an optional FindNode command that allows generation of a sandwich for a part of the original model only.


Figure 9.4: Example of a MakeSandwich command


For example, the generation of a three layer sandwich with the original layer 0.01 thick (leading to a 0.005 offset), a volume of thickness 0.002, and a second 0.01 thick shell looks like
 femesh('reset');
 femesh(';testquad4');FEel0=feutil('orient 1 n 0 0 1',FEnode,FEel0);
 femesh('divide',linspace(0,1,10),linspace(0,1,12)); 
 sandCom='makesandwich shell 0 0 .005 volume 101 .002 shell 102 -.005 .005';  
 treated='withnode{x>.5 & y>.5}'; 
 [FEnode,FEelt]=fevisco(sandCom,FEnode,FEel0,treated);
 femesh('plotelt');fecom('colordatamat');
Offsets are handled using rigid links between the shell neutral fiber and upper/lower surfaces. By default element normals at the center are used to define thickness, you can also use normals at node by inserting a -node in the command.

Notes on sandCom format:

The first layer uses 0 material property : it means that the original material property of the first layer is used. For the volume layer, 101 is used and only the thickness need to be specified (.002). The last layer is a shell (property 102) with a thickness of .001 with an offset of .005.

The command allows more accurate control of normals used for the sandwich generation. Nominally the normals are generated using the commands
    MAPE = feutil('get normalmap',node,elt);
    MAPN = feutil('get normalmap node',node,elt);
where elt is the element selection for the sandwich generation. You can provide your own maps using with a call of the form fevisco(sandCom,FEnode,FEel0,treated,MAP). It is then expected that the provided MAP has an MAP.opt field where opt(1)==1 leads to sandwich generation with offset at element center (element normal map) and opt(1)==2 uses a normal map at nodes.

StrainMap

This is an experimental command to compute membrane strains with an offset to a given shell surface. This result can be used for placement.
    smap = fevisco('StrainMap OffSet',model,def,SurfaceSelection)
    fevisco('StrainPlot',smap,def)

Test

A few test cases are provided with fevisco to allow example documentation.

TestPlate generates the model of a square plate with partial coverage using contrained layer damping on one side and free layer damping on the other side.

TestCantilever generates the model of a cantilevered constrained layer damping treatment.

WriteInclude

fevisco('WriteInclude Selection',model,FileName) is used to generate a NASTRAN bulk with name FileName containing This command is used to write the bulk for sandwich structures generated by MakeSandwich commands. Usually specific MatId are used to identify materials for the sandwich so that the selection is simply a list of material identifiers (for example 'WriteInclude MatId 1001 1002'). When called with a selection, an attempt to select the case information associated with the nodes of the selection is performed.

As an alternate format fevisco('WriteInclude',NewModel,OldModel,FileName) writes elements, nodes and properties of NewModel that are not in OldModel. Case entries of the NewModel are also written.

For example
 model=fevisco('testplate');
 model=fe_case(model,'remove','Drilling');
 tname=nas2up('tempname include.dat');
 fevisco('writeinclude MatId 101 102',model,tname);

[Write,Build] Step12

This command is used to generate parametrized reduced models in one NASTRAN run as detailed in section 6.12. From the command line, you can use fevisco('WriteStep12 -run',cf.mdl), to start the job and fevisco('BuildStep12',cf.mdl) to build the parametric model.

With the command modifier -write, writestep12 command writes the bulk model before starting job.

For in MATLAB operation you can use the fe2xf DirectFirst command.

ceig, direct

The ceig command supports advanced complex eigenvalue solutions for constant viscous and/or hysteretic damping. It is normally called through fe_ceig where the solvers are documented.

The direct command supports various direct frequency response solvers. It is normally called through fe2xf where the solvers are documented.

NASTRAN

Utilities for interfacing with NASTRAN.

MVR.zCoefFcn=fevisco('nastranzCoefv1',model,MVR) builds the proper .zCoefFcn to reproduce jobs that would otherwise run as SOL108 with one viscoelastic material.

fevisco('nastranEtaGlob',model) return the global loss factor (known PARAM,G for NASTRAN) with proper default handling.

NastranEig implements a call to NASTRAN as fe_eig method 50. To use this capability, first use the call fevisco('NastranEig') that will set preferences.

HandNomo FileName

Displays the bitmap image of a nomogram and guides the user through the process needed to obtain a tabular version suitable for inclusion in m_visco. The main steps of the procedure are as follows At any point during the procedure, you can press the i key to generate a screen printout of the material. This can then be included in m_visco or a mvisco_*.m database file.



See also

fe2xf, m_visco, section 6.6





©1991-2007 by SDTools
Previous Up Next