Shock Response Spectrum

The most widely used algorithm for the Shock Response Spectrum (SRS) calculation for base excitation is the ramp invariant digital recursive filtering relationship given in:

David O. Smallwood, An Improved Recursive Formula for Calculating Shock Response Spectra, Shock and Vibration Bulletin, No. 51, May 1981.  The link is:  DS_SRS1.pdf

Smallwood duly gave the resulting filtering coefficients in his paper, but he omitted the derivation details for brevity.

This omission is typical for papers published in journals and conference proceedings, given that derivations may require dozens of steps.

The SRS derivation requires impulse response functions, Laplace transforms and Z-transforms.

The following paper fills in the details:  ramp_invariant_base.pdf

Additional papers are given at: Vibrationdata SRS

- Tom Irvine

BLAS Update

It appears GotoBLAS2 has been deprecated (i.e. orphaned).

The new standard is OpenBLAS.

OpenBLAS is an optimized BLAS library based on GotoBLAS2 1.13 BSD version.

OpenBLAS is an open source project supported by Lab of Parallel Software and Computational Science, Institute of Software Chinese Academy of Sciences (ISCAS).

 

-Tom Irvine

Modal Transient Analysis Numerical Engine

Modal Transient Analysis of a System Subjected to an Applied Force via a Ramp Invariant Digital Recursive Filtering Relationship: force_ramp_invariant.pdf

Reference Papers:

Smallwood

Irvine General Coordinate

Irvine Impulse Response Function 1

Irvine Impulse Response Function 2

Irvine SRS

* * * * * * * * * * *

SDOF Matlab Script: arbit_force.m

MDOF Matlab Script: mdof_modal_arbit_force_ri.m

Matlab Supporting Functions:

ramp_invariant_filter_coefficients.m

enter_time_history.m

fix_size.m

Generalized_Eigen.m

mdof_plot.m

ODE_force_input.m

* * * * * * * * * * *

The same method can be applied to a multi-degree-of-freedom system with enforced motion on specified dof.

Note that the enforced motion method can also be used for base excitation if a seismic mass is inserted into the system model.  The seismic mass value may be arbitrary.

The method is given in the paper:  modal_enforced_motion_ramp_invariant.pdf

* * * * * * * * * * *

Matlab script for enforced acceleration: mdof_modal_enforced_acceleration_ri.m

Matlab script for enforced displacement: mdof_modal_enforced_displacement_ri.m

Supporting functions:

ODE_acceleration_input.m

ODE_displacement_input.m

partition_matrices.m

(Some of the previously listed functions are also required.)

* * * * * * * * * * *

Enjoy,

Tom Irvine

Engineering Employment Links

Here are  links, with an emphasis on aerospace careers.

Huntsville, Alabama

http://www.huntsvillealabamausa.com/new_exp/crp/companies/alphabetical_list.html

http://www.huntsvillespaceprofessionals.com/

http://nasajobs.nasa.gov/jobs/msfc.htm

http://www.asmartplace.com/getsmart/work_findajob.html

http://www.al.com/jobs/

Elsewhere

http://www.usajobs.gov/

https://jobs-orbital.icims.com/jobs/intro?hashed=0

http://www.ulalaunch.com/site/pages/Careers.shtml

http://www.aerojet.com/careers/

http://www.jhuapl.edu/employment/default.asp

http://www.ata-engineering.com/careers

http://www.spacex.com/careers.php

http://www.blueorigin.com/careers/careers.html

http://www.sdl.usu.edu/employment/

www.navyjobs.com

http://www.aerospacetestingalliance.com/

Tom Irvine

Vibrationdata Newsletter

I have posted the January 2012 Newsletter at:

http://www.vibrationdata.com/newsletters.htm

The topics are:

Slow Earthquakes
Rumbler Siren
Shepard Tones
Toadfish Mating Call

There are seven accompanying sound files and one Matlab script.

Please let me know if you have any questions.

Thank you,
Tom Irvine

Solve a System of Linear Equations, Ax=B

Here is a Fortran program which solves a system of linear equations: LIN_EQ.F

It is compiled via:

gfortran -o LIN_EQ LIN_EQ.F -llapack

The program uses the LAPACK subroutine: DGESV

* * *

A version written in C/C++ is given at:  linear_eq.cpp 

It is compiled via:

gcc -o linear_eq linear_eq.cpp -llapack -lstdc++

* * *

Tom Irvine

MPI

Introduction

Message Passing Interface (MPI) is a portable library of subprograms which can be used to facilitate parallel computing.

The MPI subprograms can be called from C and Fortran programs.

Parallel Computing

Parallel computing enables large scale numerical problems to be solved in a timely manner.  It can be performed on a multi-core PC, or using several networked PCs on a cluster or grid.

The key is to separate large problems into smaller ones.  The calculations are then carried out simultaneously.

The MPI subprograms regulate the communication and synchronization between the various CPUs and memory locations.

Installation

MPI can be downloaded from:
http://www.mcs.anl.gov/research/projects/mpich2/

The best installation method is to build the source code using the directions in:
http://www.mcs.anl.gov/research/projects/mpich2/documentation/files/mpich2-1.4.1-installguide.pdf

This can be done under Cygwin or Linux.

Sample Program

Then go to:  http://www.cs.usfca.edu/~peter/ppmpi/

Download the greetings.c program to the same folder which contains mpicc.

Also find and copy libmpich.a into this same folder.

Compile the program via:

mpicc -o greetings greetings.c libmpich.a

Then run the program via:

./mpirun-n 4 ./greetings

Grant persmission to run under firewalls if so prompted by pop-up windows.

The program can also be run as:

./mpiexec -n 4 ./greetings

In the above example, four processors were used.

More later . . .

* * *

Tom Irvine

GotoBLAS2

MinGW should be installed first.

Next…

GotoBLAS2

GotoBLAS2 is an implementation of Basic Linear Algebra Subprograms (BLAS).

LAPACK uses BLAS.

GotoBLAS2 has configurations for a variety of hardware platforms. It builds a library that is optimized for the given PC’s CPU.

Make a folder called: c:\LAPACK

Download GotoBLAS2. Filename = GotoBLAS2-1.13_bsd.tar.gz

http://www.tacc.utexas.edu/tacc-projects/gotoblas2/downloads/

Save File to: c:\LAPACK

Then open and extract with jZip or some other utility.

jZip is available for free at:

http://www.jzip.com/

The extracted files should appear in:

c:\LAPACK\GotoBLAS2

wget

wget – is a utility that retrieves files using HTTP, HTTPS and FTP
It will be used in the “make” process to download the latest LAPACK files.

It is given in file: wget

Copy wget into c:\MinGW

Then rename it as: wget.exe
(This approach is needed to circumvent Email firewalls.)

Next… Open the Unix-like shell

Programs > MinGW > MinGW Shell

$ cd /c/LAPACK
$ mkdir include (make include sub-folder)

Install the files from: includes.tgz     (This is for CBLAS).

Type:

$ cd /c/LAPACK/GotoBLAS2 (The $ sign is the prompt)

$ make
(this is the step to build the libraries for LAPACK & GotoBLAS2)

$ ls *.lib (directory)

You should then see a file such as:

“libgoto2_nehalemp-r1.13.lib”

Or:

“libgoto2_barcelonap-r1.13.lib”

The string in the middle depends on your CPU type.

Then type

$ nm libgoto2*.lib | grep dsptrd (file listing)

You should several lines such as
U _dsptrd_

From within the MinGW shell:

Copy includes.tgz into /c/LAPACK/include

and run: tar -zxvf includes.tgz

Also check for

C:\LAPACK\GotoBLAS2\exports\libgoto2.dll

This dll can be used for compiling programs which use LAPACK subroutines in a pure Windows environment.

More later . . .

* * *

Tom Irvine

Matrix Inversion in LAPACK

Here is a Fortran program which performs matrix inversion using the LU decomposition method:  INVERSE_MATRIX.F

It is compiled via:

gfortran -o INVERSE_MATRIX INVERSE_MATRIX.F -llapack

The program uses the subroutines: DGETRF & DGETRI

It compiles & runs under both Ubuntu & Cygwin.

See also: http://www.nag.com/numeric/fl/nagdoc_fl23/examples/source/f07ajfe.f90

* * *

Here is a similar C++ program:  matrix_inverse.cpp 

It is compiled as:

gcc -o matrix_inverse matrix_inverse.cpp -llapack -lstdc++

* * *

Tom Irvine

C/C++ Tips

Dynamic Memory Allocation for 1D Array

int* a = NULL; // Pointer to int, initialize to nothing.
int n; // Size needed for array
cin >> n; // Read in the size
a = new int[n]; // Allocate n ints and save ptr in a.
for (int i=0; i a[i] = 0; // Initialize all elements to zero.
}
. . . // Use a as a normal array
delete [] a; // When done, free memory pointed to by a.
a = NULL; // Clear a to prevent using invalid memory reference.

Alternate declaration method:

#define DYNAMIC_VECTOR(Q,nrows)\
double* Q = NULL;\
Q = new double[nrows];

******************************************************

Dynamic Memory Allocation for 2D Arrays

#define ZERO(Q,nrows,ncols) \
for(long i=0; i<nrows; i++)\
{ for(long j=0; j<ncols; j++)\
{Q[i][j]=0.;}}

#define DYNAMIC_MATRIX(Q,nrows,ncols) \
double **Q;\
Q =new double* [nrows];\
for(long row=0;row<nrows;row++) {Q[row]=new double[ncols]; }\
ZERO(Q,nrows,ncols)

#define DELETE_MATRIX(aaa,nrows)\
for (long i = 0; i < nrows; i++)\
{delete(aaa[i]);}\
delete(aaa); \

* * *

Tom Irvine