fevisco

SDT-visc Contents Functions

PDF Index

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 ??, where sample applications are treated.

AddMat,Par2Visc

model=fevisco('addmat MatId',model,'NameForMatId',mat); is used to properly append a viscoelastic material with the given MatId to the model. During this definition, one sets the reference elastic material in model.pl, the viscoelastic material definition in model.Stack{'mat','NameForMatId'} and a parameter definition in model.CStack{'par','NameForMatId'}.

If mat.pl does not contain a reference material, one is created using a call to m_visco RefMat.

The tag NameForMatId will be used for parametric model generation and fe2xf zCoef calls, if you change material you should just modify the model.Stack{'mat','NameForMatId'} data but not the parameter or the reference material. fevisco('Par2Visc',cf) uses the NameForMatId tag to check the existence of viscoelastic materials associated with matrices and modifies the zCoefFcn entries accordingly.

cf=fevisco('testplateLoadMV feplot');
cf.Stack{'info','Freq'}=[500:10:4000]';
cf.Stack{'info','Range'}=[10 20]';
% 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'}
fe2xf('zcoef',cf)

The command can also be used with reduced models, so set a viscoelastic parameter variation (_visc entry in zcoef) for a stiffness parameter that is already existing.

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 ??. The steps are

add the fluid as a superelement to the solid model
mCP=fevisco('fluidmerge',modelS,modelF).
assembly of the fluid/structure coupling and fluid matrices with the FluidMatrix command fevisco('FluidMatrix',cf, 'FluidInterfaceSel','SolidInterfaceSelection'). The fluid interface selection applies to the elements of the fluid superelement renumbered consistently for the combined model.
The result is stored in the feplot model stack as two assembled superelements which you can access with cf.Stack{'fluid'} and cf.Stack{'FSC'}. When built with fevisco one also has coup.Node,coup.Elt with the fluid interface as fsc elements and the solid interface as quad4 elements to allow verification of the matching.
Note that the coup matrix can also be imported from an external reference code that often exists in the automotive industry. fevisco('FluidMatrix',cf,coup) with coup.K, coup.sdof, coup.fdof describing the coupling matrix, solid and fluid DOFs. Solid DOFs correspond to rows of coup.K, fluid DOFs to columns.
The fevisco('fluidCheckCon',cf) can be used to check the connectivity of the coupling matrix. The distance between each coupled fluid node and structural nodes involved in the coupling is computed and the associated links are shown for verification.
compute the fluid modes and generate a reduced coupled model
[mRCoup,dflu]=fevisco('fluidMakeReduced',mCP,dsol);
which can then be used for predictions with fe2xf as illustrated in section ??.

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.

feplotStress provides stress cuts within volume. Accepted options are

MatId desired material
DefLen max arrow length
Rule integration rule
v element direction : 1 for x, 2 y, 3 z,4 normal for z revolution layer.

PA=d_visco('Script Comp13Cantilever');
comp13('solveEFracNom');  % comgui imwrite
cf=feplot(PA.MVR,PA.MVR.TR);
RA=struct('MatId','101','DefLen',.01,'rule',-1,'v',3, ...
 'Arrow','Arrow');
fevisco('feplotstress',PA.MVR,RA)

MakeModel [Matid i]

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

The MakeModel command generates this model based on a type 3 superelement where parameters are set (see upcom Par 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 ??). You can also parameterize elastic materials using 'MakeModel MatId i' where the additional elastic materials are given by i. The example given in section ??, 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 ??.

The resulting data structure MV contains all the stack entries needed for viscoelastic response computations (see section ??) : 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.

[Write,Build] Step12

This command is used to generate parameterized reduced models in one NASTRAN run as detailed in section ??. 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 option -write, writestep12 command writes the bulk model before starting job.

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

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

element nature (shell or volume)
desired material property for the meshed layer (for the starting layer use 0).
thickness of volumes, and distances of faces to neutral fiber for shells. For shells, one has two distances from the bottom layer to the neutral axis and from the neutral axis to the top layer.

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 5.1: 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 option 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 needs 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.

MatSplit

model=fevisco('MatSplit MatId -type "val"',model);
Split material MatId into multiple materials corresponding. Elements are then repeated.

svd decompose constitutive law into 6 main directions
ortho use 9 components of orthotropic material, orthu uses unit components so that coefficients to be used are the physical values
iso uses a single coefficient for the material. isoe defines the constitutive law divided by E.
rot split in radial and tangential components
EG split compression and shear
KG split bulk and shear modulus (??)
MB split membrane and bending in a shell
-ParType=1 used to define a type 1 (stiffness) parameter for each constitutive component in ortho and rot. -ParType=5 for assembly of geometric stiffness (needed for material orientation handling).
.Group={Ćomp',[1:3 7:9];'Shear',4:6}} can be used to group components into a single parameter.
m-ortho is used to define an additional homogeneous material for all elements. The associated MatId and ProId are assumed equal and should not be used by any initial element.

mo2=d_mesh('rve1fiber',struct('vf',.5,'mat','BerthCarDx','y',3,'ny',1)); 
mo2=fe_case(mo2,'remove','Matrix');
mo3=fevisco('matsplit MatId 1 -partype1 -type ortho',mo2);
[mo2,C2]=fe_case(mo3,'assemble -matdes -1 -SE -NoT');mo2

Utilities for energy display are available with MatESplit -MatId i -cut val .

Thermo

Computation of the power dissipated within a viscoelastic layer for forced response at a selected number of frequencies.

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 constrained 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

the associated nodes,
the elements selected by Selection
the rigid links and other case information connected to the nodes used by these elements
the material and element property information used by the selected elements

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);

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.