Main Page Class Hierarchy Alphabetical List Compound List File List Compound Members File Members
Newmark Class Reference#include <Newmark.h>
Inheritance diagram for Newmark::
List of all members.
Public Methods |
| | Newmark () |
| | Newmark (double gamma, double beta, bool disp=true) |
| | Newmark (double gamma, double beta, double alphaM, double betaKcurrent, double betaKinit, double betaKlastCommit, bool disp=true) |
| | ~Newmark () |
| virtual int | formEleResidual (FE_Element *theEle) |
| | Override residual calculation needed for Rayleigh damping. More...
|
| virtual int | formNodUnbalance (DOF_Group *theDof) |
| int | formEleTangent (FE_Element *theEle) |
| | to the system of equation object. More...
|
| int | formNodTangent (DOF_Group *theDof) |
| int | domainChanged (void) |
| int | initialize (void) |
| int | newStep (double deltaT) |
| int | revertToLastStep (void) |
| int | update (const Vector &deltaU) |
| virtual int | sendSelf (int commitTag, Channel &theChannel) |
| virtual int | recvSelf (int commitTag, Channel &theChannel, FEM_ObjectBroker &theBroker) |
| void | Print (ostream &s, int flag=0) |
| | Method provided for Output. More...
|
Detailed Description
Newmark is a subclass of TransientIntegrator which implements the Newmark method. In the Newmark method, to determine the velocities, accelerations and displacements at time 
, the equilibrium equation (expressed for the TransientIntegrator) is typically solved at time
for 
, i.e. solve:
for
. The following difference relations are used to relate 
and 
to 
and the response quantities at time 
:
which results in the following
An alternative approach, which does not involve 
in the denumerator (useful for impulse problems), is to solve for the accelerations at time
where we use following functions to relate
and
to
and the response quantities at time
:
which results in the following
Definition at line 117 of file Newmark.h.
Constructor & Destructor Documentation
|
Newmark::Newmark (
|
double gamma,
|
|
double beta,
|
|
bool disp = true )
|
|
|
|
Sets 
to {gamma} and 
to {beta}. Sets a flag indicating whether the incremental solution is done in terms of displacement or acceleration to {dispFlag} and a flag indicating that Rayleigh damping will not be used.
Definition at line 58 of file Newmark.cpp. |
|
Newmark::Newmark (
|
double gamma,
|
|
double beta,
|
|
double alphaM,
|
|
double betaKcurrent,
|
|
double betaKinit,
|
|
double betaKlastCommit,
|
|
bool disp = true )
|
|
|
|
Invokes the destructor on the Vector objects created.
Definition at line 88 of file Newmark.cpp. |
Member Function Documentation
|
void Newmark::Print (
|
ostream & s,
|
|
int flag = 0 ) [virtual]
|
|
|
int Newmark::domainChanged (
|
void ) [virtual]
|
|
|
|
Is called by the Analysis object. Refer to the Analysis classes to see when it is invoked. To return 
if successful, a negative number if not. This base class returns
.
Reimplemented from Integrator.
Definition at line 358 of file Newmark.cpp. |
|
int Newmark::formEleResidual (
|
FE_Element * theEle ) [virtual]
|
|
|
int Newmark::formEleTangent (
|
FE_Element * theEle ) [virtual]
|
|
|
int Newmark::formNodTangent (
|
DOF_Group * theDof ) [virtual]
|
|
|
|
To inform the DOF\_Group how to build its tangent matrix for addition to the system of equations. The subclasses must provide the implementation of this method. This is required in transient analysis as th Node objects have mass. THIS MAY CHANGE.
Reimplemented from IncrementalIntegrator.
Definition at line 341 of file Newmark.cpp. |
|
int Newmark::formNodUnbalance (
|
DOF_Group * theDof ) [virtual]
|
|
|
|
Called upon by the DOF\_Group {theDof} to determine it's contribution to the rhs of the equation. The following are invoked before
is returned. \begin{tabbing} while \= \+ while \= while \= \kill theDof-
zeroUnbalance()
Reimplemented from TransientIntegrator.
Definition at line 123 of file Newmark.cpp. |
|
int Newmark::initialize (
|
void ) [virtual]
|
|
|
int Newmark::newStep (
|
double deltaT ) [virtual]
|
|
|
|
This is a pure virtual method, one must be written for each instantiable subclass of MovableObject. Each object has to receive the data needed to be able to recreate itself in the new process after it has been sent through {theChannel}. If the object is an aggregation containing other objects, new objects of the correct type can be constructed using {theBroker}. To return
if successful or a 
if not.
Reimplemented from MovableObject.
Definition at line 539 of file Newmark.cpp. |
|
int Newmark::revertToLastStep (
|
void ) [virtual]
|
|
|
int Newmark::sendSelf (
|
int commitTag,
|
|
Channel & theChannel ) [virtual]
|
|
|
|
This is a pure virtual method, one must be written for each instantiable subclass of MovableObject. Each object has to send the data needed to be able to reproduce that object in a remote process. The object uses the methods provided by {theChannel} object to send the data to another channel at the remote actor, the address of the channel is set before this method is called. An object of similar type at the remote actor is invoked with a {receiveSelf()} to receive the data. Returns
if successful (successful in that the data got to the channel), or a
if no data was sent.
Reimplemented from MovableObject.
Definition at line 513 of file Newmark.cpp. |
|
int Newmark::update (
|
const Vector & deltaU ) [virtual]
|
|
|
|
NOTE WE CAN't DO TOGETHER BECAUSE DOF_GROUPS USING SINGLE VECTOR ****** for (int i=0; i < id.Size(); i++) { int loc = id(i); if (loc >= 0) { (*U)(loc) = disp(i); (*Udot)(loc) = vel(i); (*Udotdot)(loc) = accel(i); } }
Reimplemented from IncrementalIntegrator.
Definition at line 473 of file Newmark.cpp. |
The documentation for this class was generated from the following files:
|
Copyright
and 
. Sets a flag indicating whether the incremental solution is done in terms of displacement, 
, if {dispFlag} is {true}, or acceleration, 
, if {dispFlag} is {false}. In addition, a flag is set indicating that Rayleigh damping will not be used.
. Sets 
to {alphaM} and 
to {betaK}. Sets a flag indicating whether the incremental solution is done in terms of displacement or acceleration to {dispFlag} and a flag indicating that Rayleigh damping will be used.