SDT-rotor         Contents     Functions              PDF Index

fe_rotor

• AddMass
• Campbell
• Critical
• Whirldir
• Assemble
• RotatingLoad
• ForcedResponse
• SEBuild
• TimeOpt

Purpose

The fe_rotor function implements classical solutions for rotor dynamics applications.

AddMass

mdl=fe_rotor('AddMass',mdl,RO);
This command can be used to add a local mass on a 3d rotor mesh. The mass is added, and linked to existing node using a MPC connection.
RO is a data structure with fields

• .mxyz matrix whose first 3 columns define x y and z coordinates of added mass, and the 4th defines the mass.
• .ProId the ProId of the rotor where mass is added.

Command options are

• -DofLoad defines a 6 direction load on added masses (usefull for reduction purpose).
• -mpcmaster modifies MPC connection so that mass DOF are master ratherthan slave.

Campbell

fe_rotor('Campbell',model,RunOpt) computes the Campbell diagram and displays it with fe_rotor('plotcampbell',out,RunOpt) if no output argument is requested.
RunOpt can be a vector of rotation speeds (RPM) or a data structure with at least field .Omega containing rotation speeds and other fields giving other variables used in zCoef (for example .par field).
Accepted command options are

• -cf i can be used to force display of the diagram in a specific figure.
• -nodir avoids the call to determine the rotation direction.
• -full forces the use of full matrices. Without the argument, full matrix eigenvalue calls are only performed with less than 100 DOFs.
• -crit overlays the critical speed computation.
• -stability displays stability diagram (damping/Omega).

Examples can be found in section 3.4.1.

Critical

Computation of critical speeds. It can be called when computed Campbell using command option -crit (see Campbell).
Critical speed are computed assuming deformation is a complex mode at the same frequency as the rotation speed (w=Ω) in the global fixed frame or equal to 0 (w=0) in the local rotating frame.
In the global fixed frame:
M{X}+(C+Ω D(Ω=1)){X}+ (K+Ω² Kc(Ω=1)){X}=0
With X=X₀ exp(i Ω t)
(Ω²(−M+i D(Ω=1))+i Ω C+K){X₀}=0
In the local rotating frame:
M{X}+(C+Ω D(Ω=1)){X}+(K+Ω² Kc(Ω=1)){X}=0
With X=X₀ constant
(K+Ω² Kc(Ω=1)){X₀}=0 Examples can be found in section 3.4 xxx.

Whirldir

Internal command to display the direction of the modes on the Campbell diagrams. xxx details

Assemble

model=fe_rotor('Assemble',model,zCoef,r1); This command is used to assemble mass stiffness and damping matrices taking in account all the rotor matrices (gyroscopic coupling, centrifugal softening, etc. ...).
Default zCoef can be obtain using model=fe_def('zCoef-default',model);. r1 is a data structure whose fields are parameters used in zCoef. In particular one should specify the rotation speed r1.Omega (rad/s). Command option -cell can be used to return only matrices in a cell array.

RotatingLoad

This command builds a rotating DofLoad on a model node for frequency analysis.
model=fe_rotor('RotatingLoad NodeId f0 theta0 wexponent',model);
NodeId is the id of the node where load will be applied, f0 is the amplitude of the load, theta0 is the angle formed by the load initial direction and the first global direction in the plane orthogonal to rotation axis (x for y and z rotation and y for x rotation). The amplitude of the load can depend on a power of pulsation defined with wexponent.
Resulting complex load is of the form

in the plane orthogonal to the rotation axis (sign of +/−i depends on rotation axis).
Forced response to this load can be computed using ForcedResponse.

ForcedResponse

This command can be used to compute forced response to a frequency load (for example a rotating load built using RotatingLoad).
R1=fe_rotor('ForcedResponse',model);
Complex load must be prior defined as a 'In' entry in the case of the model.
Observation can be defined as 'output' SensDof entry. If not, only dof corresponding to the 'In' load will be returned.
Range of computation must be defined in the 'info' 'Range' Stack entry of the model as a structure of data (with fields .Omega defining rotation speeds and .w defining pulsations of the load at corresponding rotation speeds. These fields must be of the same length. If necessary one can add other fields for variables used in a defined zCoef). If .w is equal to zero, frequency dependence of load is assumed to concern the .Omega vector (it is usefull to described unbalanced mass in the local rotating frame since load amplitude depends on Ω² but load is static in this frame so that w=0).

Following example defines an unbalanced load on the simple 1d ShaftDisk model defined in d_rotor and computes the forced response (local frame):

 model=d_rotor('TestShaftDiskMdl') %  build simple model
 model=fe_caseg('assemble -se -matdes 2 1 70',model); % assemble model
 mb=1e-4; db=0.15; % mass, distance to axis
 om=linspace(0,6000,201)'; % RPM
 model=fe_rotor(sprintf('RotatingLoad 2 %.15g -90 2',mb*db),model); % unbalanced mass
 r1=struct('Omega',om/60*2*pi,'w',om/60*2*pi); % Range
 model=stack_set(model,'info','Range',r1);
 R1=fe_rotor('forcedresponse',model); % compute forced response
 iiplot(R1) % plot response

In global rotating frame, load is static (w=0). Following example deals with a rigid disk in global rotating frame:

R1=.01;R2=.15;h=0.03;
md=d_rotor(sprintf('TestVolDisk -dim%.15g %.15g %.15g 2 16',R1,R2,h));
md.DOF=[]; md=fe_caseg('assemble -se -matdes 2 1 7 8',md);
% disk assumed to be rigid :
rb=feutil('geomrb',md); cf=feplot(md); cf.def=rb;
md.K=feutil('tkt',rb.def(:,[1 3 4 6]),md.K);
md.DOF=[1.01 1.03 1.04 1.06]';
md.K{2}=0*md.K{2}; % rigid disk
md.K{2}(1,1)=5e5;md.K{2}(2,2)=5e5; % bearing
md.K{2}(3,3)=1e5;md.K{2}(4,4)=1e5; % bearing rot
% Unbalanced mass or asynchrone load :
mb=1e-4; db=0.15; % mass, distance to axis
s=0;
om=sort([2789 2750:10:2820 11760:10:11840 linspace(0,20000,101)]); % RPM
md=fe_rotor(sprintf('RotatingLoad 1 %.15g 0 2',mb*db),md); 
r1=struct('Omega',om/60*2*pi,'w',s*om/60*2*pi); % Range
md=stack_set(md,'info','Range',r1);
R1=fe_rotor('forcedresponse',md); % compute forced response
iiplot(R1) % plot response

SEBuild

This command can be used to build a superelement of rotor from a 3d rotor model. It includes Craig Bampton reduction, bearing rings adding, ...

SE=fe_rotor('SEBuild',model,RO);
model is a 3d mesh of rotor.
RO is a data structure with following fields

• .xbea vector defining position of bearings according to rotor axis.
• .bea data structure of bearing infos. bea.length is the length of the bearings, bea.Npt the number of points on one bearing, bea.ProId is the ProId of the journal.
• .mxyz is optional. Defines the mass position (reduction is performed so that DOF are created at these positions).
• .EigOpt eig option for mode computation for Craig-Bampton reduction.

One can use following options:

• -noreduce no reduction is performed.
• -rigid use rigid ring for bearings instead of rbe3 rings.

 % Lalanne 3D rotor
 model=d_rotor('TestVolShaftDiskMdl'); % Build model
 % remove bearing and boundary conitions:
 model.Elt=feutil('RemoveElt proid1000:1001',model); % remove linbearings
 model=fe_case(model,'Remove','Ends');
  % Build SE:
 RO=struct('mxyz',[0.0894892917244 0.118333333333 0.0516666666667],... Position of mass
           'EigOpt',[5 20 1e3]); % eig option for CraigBampton
 RO.xbea=[0;0.4];
 RO.bea.length=0.01;
 RO.bea.Npt=1;
 RO.bea.ProId=1; % proid of the bearing
 SE=fe_rotor('SEBuild-rigid',model,RO); % Following is now in SEbuild command

TimeOpt

model=fe_rotor('TimeOpt',model);
Defines a default TimeOpt in the 'info' 'TimeOpt' model stack entry for time integration with rotor models. Following command options are available:

• Assemble Defines AssembleCall field in order to take in account gyroscopic effects in time computation. TimeOpt field .matdes should be filled by user in order to define what matrices will be assembled. Default is [2 1 7] for mass stiffness and gyroscopic coupling matrix, see sdtweb('MatType') for available matrices (for example 8 for centrifugal softening...). Before time integration desired matrices will be assembled taking in account the 'info' 'Omega' model stack entry that defines rotation vector (norm should be equal to one so that matrices can be assembled once for different computation with different rotation speed). Rotation speed is taken as first parameter on the 'info' 'Range' model stack entry (in that case rotation vector norm must be one). If there is no Range entry, rotation is taken equal to the norm of rotation vector. Corresponding M C K matrices are then built (fe_rotor Assemble call) and will be used for Newmark time integration.