Contents     Functions         Previous Next     PDF Index

fe_load

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). Simple point loads are easily built using fe_c and reciprocity (transpose of output shape matrix) but fe_load is needed for more complex cases.

Loads are associated with cases which are structures with at least Case.DOF and Case.Stack fields.

 Case1.DOF = model.DOF; % default is model.DOF
 Case1.Stack = [{'LoadType','Name',TypeSpecificData}];

Taking the example of a point load with type specific data given by

 data=struct('DOF',365.03,'def',1);

you can create a case using low level commands

 Case1=struct('DOF',model.DOF,'Stack',{{'DofLoad','PointLoad',data}});

or with the easier case creation format (using SDT function fe_case)

 Case1=fe_case('DofLoad','PointLoad',data); 

or add a new load to a case defined in the model.Stack field

 model=fe_case(model,'DofLoad','PointLoad',data); 

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,Case). If the case is not provided, fe_load uses the first case in model.Stack.

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

DofLoad, DOFSet

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


data.name name of the case
data.DOF column vector containing a DOF selection
data.def matrix of load/set for each DOF (each column is a load/set case and the rows are indexed by Case.DOF ). With two DOFs, def=[1;1] is a single intput at two DOFs, while def=eye(2) corresponds to two inputs.
data.lab cell array giving label, unit label , and unit info (see fe_curve DataType) for each load (column of data.def)
data.curvecan specify a curve data structure (or a string referring to an existing curve) 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).
 femesh('reset');
 model = femesh('testubeam plot');
 data=struct('DOF',365.03,'def',1.1); % 1.1 N at node 365 direction z 
 data.lab=fe_curve('datatype',13);
 model=fe_case(model,'DofLoad','PointLoad',data);
 % alternate format to declare unit inputs
 model=fe_case(model,'DofLoad','ShortTwoInputs',[362.01;258.02]); 
 Load = fe_load(model);
 feplot(model,Load); fecom(';scaleone;undefline;ch1 2') % display

FVol

FVol entries use data is a structure with fields


data.selan element selection (or amodel description matrix but this is not acceptable for non-linear applications).
data.dira 3 by 1 cell array specifying the value in each global direction x, y, z. Alternatives for this specification are detailed below . The field can also be specified using .def and .DOF fields.
data.labcell array giving label, unit label , and unit info (see fe_curve DataType) for each load (column of data.def)
data.curvecan specify a curve data structure (or a string referring to an existing curve) 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).

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

 femesh('reset');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


data.sela vector of NodeId in which the faces are contained (all the nodes in a loaded face/edge must be contained in the list). data.sel can also contain any valid node selection (using string or cell array format).
 the optional data.eltsel field can be used for an optional element selection to be performed before selection of faces with feutil('selelt innode',model,data.sel). The surface is obtained using
 if isfield(data,'eltsel'); 
  mo1.Elt=feutil('selelt',mo1,data.eltsel);
 end
 elt=feutil('seleltinnode',mo1, ...
     feutil('findnode',mo1,r1.sel));
data.setAlternative specification of the loaded face by specifying a face set name to be found in model.Stack
data.defa vector with as many rows as data.DOF specifying a value for each DOF.
data.DOFDOF definition vector specifying what DOFs are loaded. Note that pressure is DOF .19. Uniform pressure can be defined using wild cards as show in the example below.
data.labcell array giving label, unit label ,and unit info (see fe_curve DataType) for each load (column of data.def)
data.curvecan specify a curve data structure (or a string referring to an existing curve) 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).

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

 femesh('reset');
 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

 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

 femesh('reset');
 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


©1991-2012 by SDTools
Previous Up Next