Main Page Class Hierarchy Alphabetical List Compound List File List Compound Members File Members
HHT Class Reference#include <HHT.h>
Inheritance diagram for HHT::
List of all members.
Detailed Description
HHT is a subclass of TransientIntegrator which implements the Hilber-Hughes-Taylor (HHT) method. In the HHT method, to determine the velocities, accelerations and displacements at time 
, by solving the following equilibrium equation
where
and the velocities and accelerations at time
are determined using the Newmark relations. The HHT method results in the following for determining the response at
\
Definition at line 79 of file HHT.h.
Constructor & Destructor Documentation
|
|
The integer INTEGRATOR\_TAGS\_HHT is passed to the TransientIntegrator constructor. 
, 
and 
are set to 0.0. This constructor should only be invoked by an FEM\_ObjectBroker.
Definition at line 47 of file HHT.cpp. |
|
HHT::HHT (
|
double alpha )
|
|
|
HHT::HHT (
|
double alpha,
|
|
double alphaM,
|
|
double betaKcurrent,
|
|
double betaKinit,
|
|
double betaKlastCommit )
|
|
|
|
Invokes the destructor on the Vector objects created.
Definition at line 82 of file HHT.cpp. |
Member Function Documentation
|
void HHT::Print (
|
ostream & s,
|
|
int flag = 0 ) [virtual]
|
|
|
int HHT::commit (
|
void ) [virtual]
|
|
|
int HHT::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 287 of file HHT.cpp. |
|
int HHT::formEleResidual (
|
FE_Element * theEle ) [virtual]
|
|
|
int HHT::formEleTangent (
|
FE_Element * theEle ) [virtual]
|
|
|
int HHT::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 273 of file HHT.cpp. |
|
int HHT::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 121 of file HHT.cpp. |
|
int HHT::initialize (
|
void ) [virtual]
|
|
|
int HHT::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 489 of file HHT.cpp. |
|
int HHT::revertToLastStep (
|
void ) [virtual]
|
|
|
int HHT::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 466 of file HHT.cpp. |
|
int HHT::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 414 of file HHT.cpp. |
The documentation for this class was generated from the following files:
|
Copyright
and 
. 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.