ParkAng.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.1 $
00022 // $Date: 2004/09/01 03:54:28 $
00023 // $Source: /usr/local/cvs/OpenSees/SRC/damage/ParkAng.cpp,v $
00024 
00025 // Written: AA,GGD 
00026 // Created: 10/02
00027 // Revision: AA
00028 //
00029 // Description: This file contains the class implementation for ParkAng 
00030 // damage model. ParkAng damage model calculates the damage index based on
00031 // primary half cycle and the summation of follower half cycles.
00032 //
00033 
00034 #include <ParkAng.h>
00035 #include <DamageResponse.h>
00036 
00037 
00038 ParkAng::ParkAng (int tag, double deltaU , double beta , double sigmaY )
00039 :DamageModel(tag,DMG_TAG_ParkAng),
00040 DeltaU( deltaU ) , Beta( beta ) , SigmaY( sigmaY )
00041 {
00042         if ( DeltaU <= 0 || Beta <= 0 , SigmaY <= 0 )
00043                 opserr << "ParkAng::ParkAng : Incorrect arguments for the damage model"<<endln;
00044 
00045         this->revertToStart();
00046 }
00047 
00048 
00049 ParkAng::ParkAng()
00050 :DamageModel(0,DMG_TAG_ParkAng)
00051 {
00052         // Does nothing
00053 }
00054 
00055 ParkAng::~ParkAng()
00056 {
00057         // Does nothing
00058 }
00059 
00060 int
00061 ParkAng::setTrial (double scalar, double scalarRate )
00062 {
00063         opserr << "WARNING: ParkAng::setTrial Wrong Method called" << endln;
00064         opserr << "ParkAng Model uses vector based setTrial method" << endln;
00065         return -1;
00066 }
00067 
00068 int
00069 ParkAng::setTrial ( Vector trialVector )
00070 {
00071         // Trial step
00072         double TForce, TDeformation, TUnloadingK, TEnergy, TMaxDefo, TDamage;
00073 
00074         // Commited state
00075         double CForce           = CommitInfo[0];;
00076         double CDeformation     = CommitInfo[1];;
00077         double CUnloadingK      = CommitInfo[2];;
00078         double CEnergy          = CommitInfo[3];;
00079         double CMaxDefo         = CommitInfo[4];;
00080         double CDamage          = CommitInfo[5];;
00081         
00082         
00083         // Deformation = trialVector(0);
00084         // Force = trialVector(1);
00085         //
00086         if ( trialVector.Size() != 3 ) {
00087                 opserr << "WARNING: ParkAng::setTrial Wrong vector size for trial data" << endln;
00088                 return -1;
00089         }
00090 
00091         TDeformation = trialVector(0);
00092         TForce = trialVector(1);
00093         TUnloadingK = trialVector(2);
00094         
00095         if ( TUnloadingK < 0.0 ) {
00096                 opserr << "WARNING: ParkAng::setTrial negative unloading stiffness specified" << endln;
00097                 return -1;
00098         }
00099 
00100         TEnergy = CEnergy + 0.5 * ( TForce + CForce ) * ( TDeformation - CDeformation );
00101 
00102         double PlasticEnergy;
00103         if (TUnloadingK != 0.0 ) {
00104                 PlasticEnergy = TEnergy - 0.5 * TForce * TForce / TUnloadingK;
00105         } else {
00106                 PlasticEnergy = TEnergy;
00107         }
00108 
00109         TMaxDefo = ( fabs( TDeformation ) > fabs( CMaxDefo ) ) ? fabs(TDeformation) : fabs(CMaxDefo);
00110 
00111         TDamage = ( TMaxDefo / DeltaU ) + ( Beta * PlasticEnergy / SigmaY / DeltaU );
00112         if ( TDamage < CDamage )  TDamage = CDamage;
00113 
00114         // Trial step
00115         TrialInfo[0] =  TForce;
00116         TrialInfo[1] =  TDeformation;
00117         TrialInfo[2] =  TUnloadingK;
00118         TrialInfo[3] =  TEnergy;
00119         TrialInfo[4] =  TMaxDefo;
00120         TrialInfo[5] =  TDamage;
00121 
00122         return 0;
00123 }
00124 
00125 
00126 int
00127 ParkAng::setTrial ()
00128 {
00129         opserr << "WARNING: ParkAng::setTrial Wrong Method called" << endln;
00130         opserr << "ParkAng Model uses vector based setTrial method" << endln;
00131         return -1;
00132 }
00133 
00134 
00135 double
00136 ParkAng::getDamage (void)
00137 {
00138         return TrialInfo[5];
00139 }
00140 
00141 
00142 double ParkAng::getPosDamage (void)
00143 {
00144         return TrialInfo[5];
00145 }
00146 
00147 
00148 double ParkAng::getNegDamage (void)
00149 {
00150         return TrialInfo[5];
00151 }
00152 
00153     
00154 int
00155 ParkAng::commitState (void)
00156 {
00157         for ( int i=0 ; i<6 ; i++ )
00158         {
00159                 LastCommitInfo[i] = CommitInfo[i];
00160                 CommitInfo[i] = TrialInfo[i];
00161         }
00162 
00163         return 0;
00164 }
00165 
00166 int
00167 ParkAng::revertToLastCommit (void)
00168 {
00169         for ( int i=0 ; i<6 ; i++ )
00170         {
00171                 CommitInfo[i] = LastCommitInfo[i];
00172         }
00173 
00174         return 0;
00175 }
00176 
00177 int
00178 ParkAng::revertToStart (void)
00179 {
00180         for ( int i = 0 ; i< 6 ; i++ ){
00181                 TrialInfo[i] = 0.0;
00182                 CommitInfo[i] = 0.0;
00183                 LastCommitInfo[i] = 0.0;
00184         }
00185 
00186         return 0;
00187 }
00188 
00189 DamageModel*
00190 ParkAng::getCopy (void)
00191 {
00192         ParkAng *theCopy = new ParkAng(this->getTag(), DeltaU , Beta , SigmaY );
00193     
00194         for ( int i=0 ; i<6 ; i++ )
00195         {
00196                 theCopy->TrialInfo[i] = TrialInfo[i];
00197                 theCopy->CommitInfo[i] = CommitInfo[i];
00198                 theCopy->LastCommitInfo[i] = LastCommitInfo[i];
00199         }
00200 
00201         return theCopy;
00202 }
00203 
00204 int
00205 ParkAng::setVariable(const char *argv)
00206 {
00207         return -1;
00208 }
00209 
00210 int
00211 ParkAng::getVariable(int variableID, double &info)
00212 {
00213         return -1;
00214 }
00215 
00216 int
00217 ParkAng::setParameter(char **argv, int argc, Information &eleInformation)
00218 {
00219     return -1;
00220 }
00221 
00222 int
00223 ParkAng::updateParameter(int responseID, Information &eleInformation)
00224 {
00225     return -1;
00226 }
00227 
00228 Response*
00229 ParkAng::setResponse(char **argv, int argc, Information &info)
00230 {
00231 //
00232 // we compare argv[0] for known response types for the Truss
00233 //
00234 
00235         if ( strcmp(argv[0],"damage") == 0 || strcmp(argv[0],"damageindex") == 0 )
00236     return new DamageResponse( this , 1 , 0.0 );
00237 
00238         else if (strcmp(argv[0],"Value") == 0 || strcmp(argv[0],"Values") == 0 || strcmp(argv[0],
00239                 "Data") == 0 )
00240     return new DamageResponse( this , 2 , Vector(3) );
00241 
00242         else if (strcmp(argv[0],"trial") == 0 || strcmp(argv[0],"trialinfo") == 0 )
00243     return new DamageResponse( this , 3 , Vector(6) );
00244 
00245         else 
00246                 return 0;
00247 
00248 }
00249 
00250 int 
00251 ParkAng::getResponse(int responseID, Information &info)
00252 {
00253         switch (responseID) {
00254         case -1:
00255                 return -1;
00256         
00257         case 1:
00258                 return info.setDouble( this->getDamage() );
00259 
00260         case 2:
00261                 if(info.theVector!=0)
00262                 {
00263                         (*(info.theVector))(0) = TrialInfo[1];
00264                         (*(info.theVector))(1) = TrialInfo[0];
00265                         (*(info.theVector))(2) = TrialInfo[2];
00266                 }
00267                 return 0;
00268 
00269         case 3:
00270                 if(info.theVector!=0)
00271                 {
00272                         (*(info.theVector))(0) = TrialInfo[0];
00273                         (*(info.theVector))(1) = TrialInfo[1];
00274                         (*(info.theVector))(2) = TrialInfo[2];
00275                         (*(info.theVector))(3) = TrialInfo[3];
00276                         (*(info.theVector))(4) = TrialInfo[4];
00277                         (*(info.theVector))(5) = TrialInfo[5];
00278                 }
00279 
00280                 return 0;
00281 
00282         default:
00283                 return -1;
00284         }
00285 }
00286 
00287 
00288 int
00289 ParkAng::sendSelf(int commitTag, Channel &theChannel)
00290 {
00291         return 0;
00292 }
00293 
00294 
00295 int
00296 ParkAng::recvSelf(int commitTag, Channel &theChannel,
00297                                                                 FEM_ObjectBroker &theBroker)
00298 {
00299         return 0;
00300 }
00301 
00302 
00303 void
00304 ParkAng::Print(OPS_Stream &s, int flag )
00305 {
00306     s << "ParkAng tag: " << this->getTag() << endln;
00307     s << "  DeltaU: " << DeltaU << " Beta: " << Beta << "  SigmaY: " << SigmaY << endln;
00308 }
00309 
00310 
00311 
00312 int ParkAng::setInputResponse ( Element *elem , const char **argv , int argc, int ndof )
00313 {
00314         return -1;
00315 }

Generated on Mon Oct 23 15:05:00 2006 for OpenSees by doxygen 1.5.0