LagrangeDOF_Group.cpp

Go to the documentation of this file.
00001 /* ****************************************************************** **
00002 **    OpenSees - Open System for Earthquake Engineering Simulation    **
00003 **          Pacific Earthquake Engineering Research Center            **
00004 **                                                                    **
00005 **                                                                    **
00006 ** (C) Copyright 1999, The Regents of the University of California    **
00007 ** All Rights Reserved.                                               **
00008 **                                                                    **
00009 ** Commercial use of this program without express permission of the   **
00010 ** University of California, Berkeley, is strictly prohibited.  See   **
00011 ** file 'COPYRIGHT'  in main directory for information on usage and   **
00012 ** redistribution,  and for a DISCLAIMER OF ALL WARRANTIES.           **
00013 **                                                                    **
00014 ** Developed by:                                                      **
00015 **   Frank McKenna (fmckenna@ce.berkeley.edu)                         **
00016 **   Gregory L. Fenves (fenves@ce.berkeley.edu)                       **
00017 **   Filip C. Filippou (filippou@ce.berkeley.edu)                     **
00018 **                                                                    **
00019 ** ****************************************************************** */
00020                                                                         
00021 // $Revision: 1.3 $
00022 // $Date: 2004/10/12 21:52:25 $
00023 // $Source: /usr/local/cvs/OpenSees/SRC/analysis/dof_grp/LagrangeDOF_Group.cpp,v $
00024                                                                         
00025 // Written: fmk 
00026 // Created: 02/99
00027 // Revision: A
00028 //
00029 // Purpose: This file contains the code for implementing the methods
00030 // of the LagrangeDOF_Group class interface.
00031 //
00032 // What: "@(#) LagrangeDOF_Group.C, revA"
00033 
00034 
00035 #include <LagrangeDOF_Group.h>
00036 #include <stdlib.h>
00037 
00038 #include <Node.h>
00039 #include <Vector.h>
00040 #include <Matrix.h>
00041 #include <TransientIntegrator.h>
00042 #include <SP_Constraint.h>
00043 #include <MP_Constraint.h>
00044 
00045 LagrangeDOF_Group::LagrangeDOF_Group(int tag, SP_Constraint &spPtr)
00046 :DOF_Group(tag, 1)
00047 {
00048 
00049 }
00050 
00051 LagrangeDOF_Group::LagrangeDOF_Group(int tag, MP_Constraint &mpPtr)
00052 :DOF_Group(tag, (mpPtr.getRetainedDOFs()).Size())
00053 {
00054 
00055 }
00056 
00057 
00058 // ~LagrangeDOF_Group();    
00059 //      destructor.
00060 
00061 LagrangeDOF_Group::~LagrangeDOF_Group()
00062 {
00063 
00064 }    
00065 
00066 const Matrix &
00067 LagrangeDOF_Group::getTangent(Integrator *theIntegrator)
00068 {
00069     // does nothing - the Lagrange FE_Elements provide coeffs to tangent
00070     if (tangent == 0) {
00071         int numDOF = this->getNumDOF();
00072         tangent = new Matrix(numDOF,numDOF);
00073         
00074         if (tangent == 0) {
00075             opserr << "FATAL LagrangeDOF_Group::getTangent() ";
00076             opserr << " ranout of memory\n";
00077             exit(-1);
00078         }
00079     }
00080     
00081     tangent->Zero();
00082     return *tangent;
00083     
00084 }
00085 
00086 const Vector &
00087 LagrangeDOF_Group::getUnbalance(Integrator *theIntegrator)
00088 {
00089     // does nothing - the Lagrange FE_Elements provide residual 
00090     unbalance->Zero();
00091     return *unbalance;
00092 }
00093 
00094 // void setNodeDisp(const Vector &u);
00095 //      Method to set the corresponding nodes displacements to the
00096 //      values in u, components identified by myID;
00097 
00098 void
00099 LagrangeDOF_Group::setNodeDisp(const Vector &u)
00100 {
00101     return;
00102 }
00103         
00104         
00105 // void setNodeVel(const Vector &udot);
00106 //      Method to set the corresponding nodes velocities to the
00107 //      values in udot, components identified by myID;
00108 
00109 void
00110 LagrangeDOF_Group::setNodeVel(const Vector &udot)
00111 {
00112     return;
00113 }
00114 
00115 
00116 
00117 // void setNodeAccel(const Vector &udotdot);
00118 //      Method to set the corresponding nodes accelerations to the
00119 //      values in udotdot, components identified by myID;
00120 
00121 void
00122 LagrangeDOF_Group::setNodeAccel(const Vector &udotdot)
00123 {
00124     return;
00125 }
00126 
00127 
00128 // void setNodeIncrDisp(const Vector &u);
00129 //      Method to set the corresponding nodes displacements to the
00130 //      values in u, components identified by myID;
00131 
00132 void
00133 LagrangeDOF_Group::incrNodeDisp(const Vector &u)
00134 {
00135     return;
00136 }
00137         
00138         
00139 // void setNodeincrVel(const Vector &udot);
00140 //      Method to set the corresponding nodes velocities to the
00141 //      values in udot, components identified by myID;
00142 
00143 void
00144 LagrangeDOF_Group::incrNodeVel(const Vector &udot)
00145 {
00146     return;
00147 }
00148 
00149 
00150 
00151 // void setNodeIncrAccel(const Vector &udotdot);
00152 //      Method to set the corresponding nodes accelerations to the
00153 //      values in udotdot, components identified by myID;
00154 
00155 void
00156 LagrangeDOF_Group::incrNodeAccel(const Vector &udotdot)
00157 {
00158     return;
00159 }
00160 
00161 
00162 const Vector &
00163 LagrangeDOF_Group::getCommittedDisp(void)
00164 {
00165     unbalance->Zero();
00166     return *unbalance;
00167 }
00168 
00169 const Vector &
00170 LagrangeDOF_Group::getCommittedVel(void)
00171 {
00172     unbalance->Zero();
00173     return *unbalance;
00174 }
00175 
00176 const Vector &
00177 LagrangeDOF_Group::getCommittedAccel(void)
00178 {
00179     unbalance->Zero();
00180     return *unbalance;
00181 }
00182 
00183 void  
00184 LagrangeDOF_Group::addMtoTang(double fact)
00185 {
00186 }
00187 
00188 void  
00189 LagrangeDOF_Group::zeroUnbalance(void)
00190 {
00191 }
00192 
00193 void  
00194 LagrangeDOF_Group::zeroTangent(void)
00195 {
00196 }
00197 
00198 void  
00199 LagrangeDOF_Group::addPtoUnbalance(double fact)
00200 {
00201 
00202 }
00203 
00204 void  
00205 LagrangeDOF_Group::addPIncInertiaToUnbalance(double fact)
00206 {
00207 
00208 }
00209 
00210 void  
00211 LagrangeDOF_Group::addM_Force(const Vector &Udotdot, double fact)
00212 {
00213 
00214 }
00215 
00216 const Vector &
00217 LagrangeDOF_Group::getTangForce(const Vector &disp, double fact)
00218 {
00219   opserr << "WARNING LagrangeDOF_Group::getTangForce() - not yet implemented\n";
00220   unbalance->Zero();
00221   return *unbalance;
00222 }
00223 
00224 const Vector &
00225 LagrangeDOF_Group::getC_Force(const Vector &disp, double fact)
00226 {
00227   unbalance->Zero();
00228   return *unbalance;
00229 }
00230 
00231 const Vector &
00232 LagrangeDOF_Group::getM_Force(const Vector &disp, double fact)
00233 {
00234   unbalance->Zero();
00235   return *unbalance;
00236 }
00237 
00238 

Generated on Mon Oct 23 15:04:57 2006 for OpenSees by doxygen 1.5.0