Contents     Functions              PDF Index

fe_load

• curve
• DofLoad, DofSet
• FVol
• FSurf

Purpose

Interface for the assembly of distributed and multiple load patterns

Syntax

 Load = fe_load(model)
 Load = fe_load(model,Case)
 Load = fe_load(model,'NoT')
 Load = fe_load(model,Case,'NoT')

Description

fe_load is used to assemble loads (left hand side vectors to FEM problems). Loads are associated with case structures with at least a Case.Stack field giving all the case entries. Addition of entries to the cases, it typically done using fe_case.

To compute the load, the model (a structure with fields .Node, .Elt, .pl, .il) must generally be provided with the syntax Load=fe_load(model). In general simultaneous assembly of matrices and loads detailed in section 4.8.8 is preferable.

The option NoT argument is used to require loads defined on the full list of DOFs rather than after constraint eliminations computed using Case.T'*Load.def.

The rest of this manual section describes supported load types and the associated type specific data.

curve

The frequency or time dependence of a load can be specified as a data.curve field in the load case entry. This field is a cell array specifying the dependence for each column of the applied loads.

Each entry can be a curve data structure, or a string referring to an existing curve (stored in the model.Stack), to describe frequency or time dependence of loads.

Units for the load are defined through the .lab field (in {F}=[B]{u} one assumes u to be unitless thus F and B have the same unit systems).

DofLoad, DofSet

Loads at DOFs DofLoad and prescribed displacements DofSet entries are described by the following data structure

Typical initialization is illustrated below

% Applying a load case in a model
 model = femesh('testubeam plot');
 % Simplified format to declare unit inputs
 model=fe_case(model,'DofLoad','ShortTwoInputs',[362.01;258.02]); 

 % General format with amplitudes at multiple DOF
 % At node 365, 1 N in x and 1.1 N in z 
 data=struct('DOF',[365.01;365.03],'def',[1;1.1]); 
 data.lab=fe_curve('datatype',13);
 model=fe_case(model,'DofLoad','PointLoad',data);

 Load = fe_load(model);
 feplot(model,Load); fecom(';scaleone;undefline;ch1 2') % display

When sensors are defined in SDT, loads collocated with sensors can be defined using sensor DofLoadSensDof.

FVol

FVol entries use data is a structure with fields

Each cell of Case.dir can give a constant value, a position dependent value defined by a string FcnName that is evaluated using
fv(:,jDir)=eval(FcnName) or fv(:,jDir)=feval(FcnName,node) if the first fails. Note that node corresponds to nodes of the model in the global coordinate system and you can use the coordinates x,y,z for your evaluation. The transformation to a vector defined at model.DOF is done using vect=elem0('VectFromDir',model,r1,model.DOF), you can look the source code for more details.

For example

% Applying a volumic load in a model
 model = femesh('testubeam');
 data=struct('sel','groupall','dir',[0 32 0]);
 data2=struct('sel','groupall','dir',{{0,0,'(z-1).^3.*x'}});
 model=fe_case(model,'FVol','Constant',data, ...
                     'FVol','Variable',data2);
 Load = fe_load(model); 
 feplot(model,Load);fecom(';colordataz;ch2'); % display

Volume loads are implemented for all elements, you can always get an example using the elements self tests, for example [model,Load]=beam1('testload').

Gravity loads are not explicitly implemented (care must be taken considering masses in this case and not volume). You should use the product of the mass matrix with the rigid body mode corresponding to a uniform acceleration.

FSurf

FSurf entries use data a structure with fields

% Surface selection mechanism performed for a FSurf input
 if isfield(data,'eltsel'); 
  mo1.Elt=feutil('selelt',mo1,data.eltsel);
 end
 elt=feutil('seleltinnode',mo1, ...
     feutil('findnode',mo1,r1.sel));

Surface loads are defined by surface selection and a field defined at nodes. The surface can be defined by a set of nodes (data.sel and possibly data.eltsel fields. One then retains faces or edges that are fully contained in the specified set of nodes. For example

% Applying a surfacing load case in a model using selectors
 model = femesh('testubeam plot');
 data=struct('sel','x==-.5', ... 
             'eltsel','withnode {z>1.25}','def',1,'DOF',.19);
 model=fe_case(model,'Fsurf','Surface load',data);
 Load = fe_load(model); feplot(model,Load);

Or an alternative call with the cell array format for data.sel

% Applying a surfacing load case in a model using node lists
 data=struct('eltsel','withnode {z>1.25}','def',1,'DOF',.19);
 NodeList=feutil('findnode x==-.5',model);
 data.sel={'','NodeId','==',NodeList};
 model=fe_case(model,'Fsurf','Surface load',data);
 Load = fe_load(model); feplot(model,Load);

Alternatively, one can specify the surface by referring to a set entry in model.Stack, as shown in the following example

% Applying a surfacing load case in a model using sets
 model = femesh('testubeam plot');

 % Define a face set
 [eltid,model.Elt]=feutil('eltidfix',model);
 i1=feutil('findelt withnode {x==-.5 & y<0}',model);i1=eltid(i1);
 i1(:,2)=2; % fourth face is loaded
 data=struct('ID',1,'data',i1);
 model=stack_set(model,'set','Face 1',data);

 % define a load on face 1
 data=struct('set','Face 1','def',1,'DOF',.19);
 model=fe_case(model,'Fsurf','Surface load',data);
 Load = fe_load(model); feplot(model,Load)

The current trend of development is to consider surface loads as surface elements and transform the case entry to a volume load on a surface.

See also

fe_c, fe_case, fe_mk