To reduce vibration and noise, a damping layer and constraint layer are usually pasted on the inner surface of a gearbox thin shell, and their thicknesses are the main parameters in the vibration and noise reduction design. The normal acceleration of the point on the gearbox surface is the main index that can reflect the vibration and noise of that point, and the normal accelerations of different points can reflect the degree of the vibration and noise of the whole structure. The K-S function is adopted to process many points’ normal accelerations as the comprehensive index of the vibration characteristics of the whole structure, and the vibration acceleration level is adopted to measure the degree of the vibration and noise. Secondary development of the Abaqus preprocess and postprocess on the basis of the Python scripting programming automatically modifies the model parameters, submits the job, and restarts the analysis totally, which avoids the tedious work of returning to the Abaqus/CAE for modifying and resubmitting and improves the speed of the preprocess and postprocess and the computational efficiency.
A gear-box, which is a lamella shell structure, mainly includes an upper box and under box. The upper box is composed of arched shell, and connections are used to close the gearbox; this is the thinnest structure of the whole gearbox where the vibration of structure and noise mainly occur. Therefore, it is very necessary to improve the design of the arched shell for reducing the vibration and noise of the gear box. For this purpose, a constrained damping is always used for dealing with the box structures [ 1]. On the inner faces of the thin steel shell of the box structure high-damping viscoelastic materials are pasted to form the damping layer, which is then fixed by a thin steel plate and called the constraint layer. Through this approach, the stiffness and damping of the whole structure are strengthened, and the vibration and noise are also reduced [ 2, 3].
The Kreisselmerier-Steinhauser function (K-S function) was first proposed in the design of the control system. Then, it was used to solve the min-max problem in structure optimization design as a method that translates multiconstraint functions into a single accumulative function [ 4].
Generally, vibration is described with the vibration displacement, vibration velocity, and vibration acceleration. Regardless of the measuring displacement, velocity, or acceleration of the vibrating object, the form of vibration signals and frequency components are similar. The vibration level can be a similar form in decibels to noise level [ 5]. Usually, the vibration acceleration is treated as the measurement unit. The vibration acceleration level is a synthesized parameter to note the vibration effects of damping devices.
 | Fig.1 Abaqus scripting interface commands and Abaqus/CAE (graphical user interface (GUI); command line interface (CLI); and script files) |
Abaqus is widely supplied in engineering and can simulate the linear and nonlinear behavior of most engineering materials. The Abaqus/CAE module is a human-machine interface where the preprocess and postprocess of finite element simulation can dispose. The modules and data in Abaqus are transmitted by kernel script language Python, which is an object oriented language. Abaqus provides many library functions in Python for user. The operation function of Abaqus is enforced by calling these library functions in Abaqus scripting interface. The script language can be transmitted into kernel of Abaqus through three forms shown in Fig. 1 [ 6].
The following functions can be achieved through Abaqus kernel script language Python:
1) Create or modify the model parameter, e.g., properties of material, model size, loading type, element type, and shape.
2) Create or modify Abaqus analysis tasks.
3) Operate on field output and history output data, such as reading the geometry data of different parts and node coordinates, operating the output data in specified analysis step and outputting the history analysis data.
4) View the results of an analysis.
5) Realize the parametric analysis. For example, you can modify the geometry parameter of the part to complete some different cases analyses by a script language.
 | Fig.2 Structure of the Abaqus object model |
The Abaqus script interface is an object oriented program library where each object has corresponding members and functions. Abaqus provides an application program interface to achieve the preprocess and postprocess of models. This interface programmed in python provides about 500 object oriented models. The relationships of these models are very complex as shown in Fig. 2. Here, container and singular object denote a class including other object and one object, individual. The whole object-oriented models can be classified three forms: session objects that are used to define the view, Mdb objects that include model database and analysis tasks, and Odb objects that include model database and analysis results.
Abaqus secondary development can be realized in four methods [ 7]: 1) User subroutines, which can be developed to control the simulation process and operating analysis results; 2) Abaqus environment files, which can change many default values of Abaqus; 3) Abaqus scripting interface, the preprocess, and postprocess of models can be controlled by script commands; and 4) Abaqus GUI Toolkit, a new GUI interface can be created by it.
This paper studies the vibration and noise reduction of the gearbox using Abaqus secondary development. By using secondary development, the thickness of the original layer, damping layer, and constraint layer are modified individually. The effect of vibration and noise reduction of the gearbox can be obtained at different layer thicknesses. Some operations, such as modifying geometry models, submitting tasks, and restarting analysis, are realized using python in the analysis procedure. Therefore, the computation efficiency of numerical simulation is improved. For study of vibration and noise reduction of the gearbox, first, some representative points that can reflect vibration characters of the whole gearbox are created. Then, normal acceleration of these points is simplified into a single data through K-S function. Finally, the vibration acceleration level that can measure the vibration, and noise is used to estimate the effect of vibration reduction. The steps are as follows:
1) Create the finite element model of the arched shell of the gear box in the Abaqus GUI.
2) Program a subroutine that can modify model parameters and create a new task.
3) Program a subroutine that can read and operate the results of simulation.
4) In the script interface of Abaqus, create a dialog box and calling subroutines realized through script commands.
The first step is realized in the GUI and others are realized by inputting Python language commands through command line interface, CLI, which allows bypassing the Abaqus/CAE GUI and communicating directly with the kernel. All the Python language commands are programmed in accordance with Ref. [ 8].
In this paper, the arched shell is separated from the gearbox. The finite element model of the arched shell is created in the Abaqus GUI, as shown in Fig. 3. Unit white noise in the scope of 1-2000 Hz is loaded in the middle of the arched shell. To simplify boundary conditions, the sides’ displacements of the arched shell are fixed.
 | Fig.3 Finite model of arch shell |
Some work must be prepared for Abaqus secondary development. First, the arched shell is created using the composite material shell model. Material properties of the basic layer, damping layer, and constraint layer of the arched shell are steel, damping, and steel, individually. The thickness of each layer in the arched shell is 12, 8, and 1 mm, individually. Then, five representative points are selected for reflecting the dynamic property of the whole gearbox, as shown in Fig. 4. Finally, some necessary settings must be done to output acceleration values of the representative points in the history output manager. This operation can be done in an input file (*.inp).
 | Fig.4 Location of representative points |
The dynamic response analysis of the arched shell divided into two parts including the nature frequency analysis and random response analysis. To facilitate the secondary development, the restart analysis is directly created in the file random_restart.inp. This file is saved in the folder that includes the finite element model gongban_damp.cae.
In the script manager of Abaqus/CAE, these operations, such as modifying the thickness of arched shell, submitting modal analysis task, and calling the ABAQUS6.5 solver to complete restart the analysis, are realized by a function Analysis( t), where the parameter t is the combination of the thickness of each layer. The codes of the function are given as follows:
from abaqus import *
from abaqusConstants import *
def Analysis(t):
from caeModules import *
import job
openMdb(pathName='e:/Temp/gongban_damp.cae')
a= mdb.models['gongban_damp'].rootAssembly
model= mdb.models['gongban_damp']
[x,y,z]=t ## set combination of the thickness of each layer to t
# create the shellSections
sectionLayer1=section.SectionLayer(material='STEEL', thickness=x, orientAngle=0.0, numIntPts=3)
sectionLayer2= section.SectionLayer(material='DAMP', thickness=y, orientAngle=0.0, numIntPts=3)
sectionLayer3= section.SectionLayer(material='STEEL', thickness=z, orientAngle=0.0, numIntPts=3)
# set values of the sectionLayers to the shellSections
a= mdb.models['gongban_damp'].rootAssembly
#create job named 'gongban_damp'
mdb.jobs['gongban_damp'].submit( ) ## submit the job
mdb.jobs['gongban_damp'].waitForCompletion( ) ## wait for job completion
import os ## call the os module into the system function
os.system('echo gongban_damp | abq656.exe job=random_restart.inp oldjob=gongban_damp') ## restart analysis
print 'The random restart analysis has been done!'
 | Fig.5 Odb object model |
After finishing the modal analysis and restart analysis, the simulation results are saved in gongban_damp.odb and random_restart.odb. These files can be found in the folder E:/Temp. The tree diagram of numerical results is shown in Fig. 5. Normal acceleration values of all the representative points can be read from the result data file. These data can be operated in the postprocess.
Because only five representative points are considered in the analysis, the normal acceleration in the five points cannot be responsive the vibration of the whole structure. To reflect the vibration of the whole structure, the normal accelerations of five representative points are operated into a single value through the K-S function. The K-S function [ 9] can be expressed as
| (1) |
A vibration acceleration level is a parameter used to estimate the effect of vibration reduction. In this paper, the vibration acceleration level of normal acceleration is used to estimate the effect of vibration reduction. A function of vibration acceleration level is given by
| (2) |
In the postprocess, first, the maximum normal accelerations and the corresponding frequencies of the five representative points are extracted. Then, these maximum accelerations are processed as a synthesized parameter by the K-S function, and the vibration acceleration level (VAL) is obtained to evaluate vibration and noise reduction. Finally, all the outputs are written into the txt file. The steps above are realized by a function getResults( t), where the parameter t is the combination of the thickness of each layer of the arched shell with constraint damping. Because the random response analysis is based on the frequency, the results are pairs with the frequency and acceleration. Therefore, the data of this type are well considered in the below function definition. The codes of the function are partly given as follows:
def getResults(t):
from odbAccess import *
from math import *
u= pi/4.0
# create five lists named list1, list2, list3, list4, and list5, and all the initial values are zero.
file= open(‘result.txt’,’w’) ## define the results file
odb= openOdb(path='E:/Temp/random_restart.odb')
step2= odb.steps['Step-2']
num= len(step2.historyRegions['Node PART-1-1.823'].historyOutputs['A1'].data) ## the output length
i=0
while i
for regionName in step2.historyRegions.keys():
region= step2.historyRegions[regionName]
A1Data= region.historyOutputs['A1'].data
A2Data= region.historyOutputs['A2'].data
if regionName== 'Node PART-1-1.823':
frequency1= A1Data[i][0]
acceleration1= A1Data[i][1]
list1.append(acceleration1) ## put the normal accelerations of Node PART-1-1.823 into list1
elif regionName== 'Node PART-1-1.541':
acceleration2= (A1Data[i][1]+A2Data[i][1])*sin(u)
list2.append(acceleration2) ## put the normal accelerations of Node PART-1-1.541 into list2
elif regionName== 'Node PART-1-1.1175':
acceleration3= (A1Data[i][1]+A2Data[i][1])*sin(u)
list3.append(acceleration3) ## put the normal accelerations of Node PART-1-1.1175 into list3
elif regionName== 'Node PART-1-1.698':
acceleration4= (A1Data[i][1]+A2Data[i][1])*sin(u)
list4.append(acceleration4) ## put the normal accelerations of Node PART-1-1.698 into list4
elif regionName== 'Node PART-1-1.1388':
acceleration5= A2Data[i][1]
list5.append(acceleration5) ## put the normal accelerations of Node PART-1-1.1388 into list5
i= i+1
# fetch the MaxAccleration and frequency for each node from the five lists and print them to the file
p= 4.0
sum= exp(p*max(list1))+exp(p*max(list2))+exp(p*max(list3))+exp(p*max(list4))+exp(p*max(list5))
a= (1/p)*log(sum) ##the synthesized parameter
print>>file,'The general standard of vibration intension is a= %f' % a
c= 1e-3
L= 20 * log10(a/c) ##the vibration acceleration level
print>>file,'The noise factor of vibration is L= %f' % L
file.close ()
odb.close()
When the functions in preprocess and postprocess are created, a function known as getInputs is called to create a dialog box. The title of this dialog box is “Design Thickness” and has three input boxes used to input the layers thickness of the arched shell, as shown in Fig. 6.
 | Fig.6 Input design thickness |
The default design thickness values are (BasePlate, Dampplate, and RestrictPlate) = (12.0, 8.0, and 1.0). If the users choose the cancel key to quit entering, getInputs function will give out a None. Therefore, it is necessary to enter design values, otherwise, the following functions, Analysis( t) and getResults( t), cannot operate normally. Generally, after the completion of calculation, the computer needs buffer to write the data into the ODB file completely. In this circumstance, the time function sleep( time), where time is the length of sleep duration and can be set personally, is called to set the process of dormancy and to make the system wait for the buffer completion. Here, we set 50 s for the sleep duration. The codes are given as follows:
from abaqus import getInputs
fields= (('BasePlate:','12.0'), ('DampPlate:', '8.0'),('RestrictPlate:', '1.0'))
BasePlate,DampPlate,RestrictPlate=getInputs(fields=fields, label='Enter the thickness for the Plates:',
dialogTitle='Design Thickness', )
t= (BasePlate,DampPlate,RestrictPlate)
import time
Analysis(t)
time.sleep(50)
getResults(t)
The result file can be found in the folder E:/Temp. In the file, the result data include the max normal acceleration on the five representative points, relative frequency, value determined by the K-S function, and vibration acceleration level. For example, it is assumed that the three layers of the arched shell are 12.0, 7.5, and 1.0, respectively. The result file is shown in Table 1.
 | Tab.1 Output results |
The data in Table 1 show that, when the thickness of the base layer, damping layer, and constraint layer are 12.0 mm, 7.5 mm, and 1.0 mm, respectively, Nos. 1, 4, and 5 representative points have the maximum normal acceleration at 203.68 Hz, and Nos. 2 and 3 representative points have the maximum normal acceleration value 4.73 mm/s2 at 121.26 Hz and 6.60 mm/s2 at 176.11 Hz, respectively. Meanwhile, the maximum normal acceleration of No. 4 is the largest of the five. This shows that vibration at No. 4 is more severe than at other points. After the maximum normal accelerations of the five points are processed by the K-S function, the synthesized parameter is 23.79 mm/s2, and the corresponding vibration acceleration level is 147.53 dB.
Through the above example, it is found that by inputting parameters to the dialog box in Fig. 6, the Abaqus preprocess function Analysis( t) and the postprocess function getResults( t) are called to compute the maximum normal acceleration and corresponding frequencies of all representative points. Then, the synthesized parameter and the vibration acceleration level are also obtained.
In this paper, the Abaqus script interface and Python language are used to develop the preprocess and postprocess programming. The preprocess secondary development includes modifying the thickness of the arched shell with constraint damping automatically based on the built FEM model, submitting the job to compute, and restarting analysis. Many steps are saved to modify the thickness and resubmit the job on the Abaqus graphical user interface. The efficiency of the software Abaqus is also improved in this way.
The postprocess secondary development mainly deals with the results. The K-S function is adopted to obtain a synthesized parameter used for describing the vibration characteristics of the whole structure. Then, the vibration acceleration level (VAL) is taken as the evaluation parameter of vibration and noise reduction. It lays the foundation for the optimal design of the thickness of the arched shell with constraint damping and cuts down the time of data extraction and data processing sharply. Especially, the data processing of the five representative points has realized the kernel interaction and the automatic program running by Python language commands perfectly, without repeated operations of five times data extraction. It expands the postprocess capability effectively and improves the ability of Abaqus to analyze problems.
| 1 |
|
| 2 |
|
| 3 |
|
| 4 |
|
| 5 |
|
| 6 |
|
| 7 |
|
| 8 |
|
| 9 |
|