NormalizedPeak.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/NormalizedPeak.cpp,v $
00024 
00025 // Written: Arash Altoontash, Gregory Deierlein
00026 // Created: 08/02
00027 // Revision: AA
00028 //
00029 // Description: This file contains the class implementation for Damage model  .
00030 //
00031 
00032 #include <NormalizedPeak.h>
00033 #include <DamageResponse.h>
00034 #include <Element.h>
00035 
00036 
00037 NormalizedPeak::NormalizedPeak(int tag, double maxVal, double minVal , const char *argv)
00038 :DamageModel(tag,DMG_TAG_NormalizedPeak), damagetype( NotSpecified ), 
00039 MaxValue(maxVal), MinValue(minVal), TrialDmg(0.0), CommitDmg(0.0), LCommitDmg(0.0),
00040 TrialVector(3), CommitVector(3), LCommitVector(3)
00041 {
00042   if ( MaxValue < 0.0 || MinValue > 0.0 || argv == NULL )
00043     {
00044       opserr << "NormalizedPeak::NormalizedPeak : Incorrect arguments for the damage model";
00045       exit (-1);
00046     }
00047   
00048   strcpy ( damagename, argv);
00049   
00050   
00051   if ( strcmp( damagename , "force" ) == 0 || strcmp( damagename , "Force" ) == 0 )
00052     {
00053       damagetype = Force;
00054     }
00055   else if ( strcmp( damagename , "strain" ) == 0 || strcmp( damagename , "Strain" ) == 0 ||
00056             strcmp( damagename , "defo" ) == 0 || strcmp( damagename , "deformation" ) == 0 ||
00057             strcmp( damagename , "Deformation" ) == 0 )
00058     {
00059       damagetype = Deformation;
00060     }
00061   else if ( strcmp( damagename , "plasticDefo" ) == 0 || strcmp( damagename , "PlasticDefo" ) == 0 ||
00062             strcmp( damagename , "plasticStrain" ) == 0 || strcmp( damagename , "PlasticStrain" ) == 0 ||
00063             strcmp( damagename , "plasticDeformation" ) == 0 || strcmp( damagename , "PlasticDeformation" ) == 0 )
00064     {
00065       damagetype = PlasticDefo;
00066     }
00067   else if ( strcmp( damagename , "energy" ) == 0 || strcmp( damagename , "Energy" ) == 0 ||
00068             strcmp( damagename , "totalEnergy" ) == 0 || strcmp( damagename , "TotalEnergy" ) == 0 )
00069     {
00070       damagetype = TotalEnergy;
00071     }
00072   else if ( strcmp( damagename , "plasticDefo" ) == 0 || strcmp( damagename , "PlasticDefo" ) == 0 ||
00073             strcmp( damagename , "plasticStrain" ) == 0 || strcmp( damagename , "PlasticStrain" ) == 0 ||
00074             strcmp( damagename , "plasticDeformation" ) == 0 || strcmp( damagename , "PlasticDeformation" ) == 0 ){
00075     damagetype =        PlasticEnergy;
00076   }
00077   else
00078     {
00079       opserr << "NormalizedPeak::NormalizedPeak : The damage type specified is not supported";
00080       exit (-1);        
00081     }
00082   
00083   this->revertToStart();
00084 }
00085 
00086 
00087 NormalizedPeak::NormalizedPeak()
00088   :DamageModel(0,DMG_TAG_NormalizedPeak)
00089 {
00090   // Does nothing
00091 }
00092 
00093 NormalizedPeak::~NormalizedPeak()
00094 {
00095   // Does nothing
00096 }
00097 
00098 
00099 DamageModel*
00100 NormalizedPeak::getCopy (void)
00101 {
00102   NormalizedPeak *theCopy = new NormalizedPeak( this->getTag(), MaxValue, MinValue , damagename);
00103   
00104   theCopy->TrialScalar = TrialScalar;
00105   theCopy->TrialDmg = TrialDmg;
00106   theCopy->CommitScalar = CommitScalar;
00107   theCopy->CommitDmg = CommitDmg;
00108   theCopy->LCommitScalar = LCommitScalar;
00109   theCopy->LCommitDmg = LCommitDmg;
00110   
00111   for ( int i=0 ; i < 3 ; i++ )
00112     {
00113       (theCopy->TrialVector)(i) = TrialVector(i);
00114       (theCopy->CommitVector)(i) = CommitVector(i);
00115       (theCopy->LCommitVector)(i) = LCommitVector(i);
00116     } 
00117   
00118   return theCopy;
00119 }
00120 
00121 
00122     
00123 int
00124 NormalizedPeak::commitState (void)
00125 {
00126   LCommitScalar = CommitScalar;
00127   LCommitDmg = CommitDmg;
00128   LCommitVector = CommitVector;
00129   
00130   CommitScalar = TrialScalar;
00131   CommitDmg = TrialDmg;
00132   CommitVector = TrialVector;
00133   
00134   return 0;
00135 }
00136 
00137 int
00138 NormalizedPeak::revertToLastCommit (void)
00139 {
00140   CommitScalar = LCommitScalar;
00141   CommitDmg = LCommitDmg;
00142   
00143   CommitVector = LCommitVector;
00144   
00145   return 0;
00146 }
00147 
00148 int
00149 NormalizedPeak::revertToStart (void)
00150 {
00151   TrialScalar = CommitScalar = LCommitScalar = 0.0;
00152   TrialDmg = CommitDmg = LCommitDmg = 0.0;
00153   TrialVector.Zero();
00154   CommitVector.Zero();
00155   LCommitVector.Zero();
00156   
00157   return 0;
00158 }
00159 
00160 
00161 int
00162 NormalizedPeak::setTrial ( Vector trialVector )
00163 {
00164   if ( trialVector.Size() < 3 ) {
00165     opserr << "WARNING: NormalizedPeak::setTrial Wrong vector size for trial data" << endln;
00166     return -1;
00167   }
00168   
00169   TrialVector = trialVector;
00170   
00171   double TrialDefo = trialVector(0);
00172   double TrialForce = trialVector(1);
00173   double TrialKU = trialVector(2);
00174   
00175   TrialScalar = 0.0;
00176   
00177   switch( damagetype )
00178     {
00179     case Force:
00180       TrialScalar = TrialVector(1);
00181       break;
00182     case Deformation:
00183       TrialScalar = TrialVector(0);
00184       break;
00185     case PlasticDefo:
00186       if ( TrialVector(2) != 0.0 )
00187         { TrialScalar = TrialVector(0) - TrialVector(1)/TrialVector(2); }
00188       else { TrialScalar = TrialVector(0); }
00189       break;
00190     case TotalEnergy:
00191       TrialScalar = CommitScalar + 0.5*( TrialVector(1) + CommitVector(1) )*( TrialVector(0) - CommitVector(0) );
00192       break;
00193     case PlasticEnergy:
00194       if ( TrialVector(2) > 0.0 )
00195         TrialScalar = CommitScalar + 0.5*( TrialVector(1) + CommitVector(1) )*( TrialVector(0) - CommitVector(0) )
00196           - 0.5* TrialVector(1) * TrialVector(1) / TrialVector(2);
00197       break;
00198     }
00199   
00200   // Now calculate damage
00201   if ( TrialScalar >= 0.0 ) {
00202     TrialDmg = TrialScalar / MaxValue;
00203   } else {
00204     TrialDmg = fabs( TrialScalar / MinValue );
00205   }
00206   
00207   if ( fabs(TrialDmg) < CommitDmg ) TrialDmg = CommitDmg;
00208   
00209   return 0;
00210 }
00211 
00212 
00213 double
00214 NormalizedPeak::getDamage (void)
00215 {
00216   return TrialDmg;
00217 }
00218 
00219 
00220 
00221 double NormalizedPeak::getPosDamage (void)
00222 {
00223   return TrialDmg;
00224 }
00225 
00226 
00227 double NormalizedPeak::getNegDamage (void)
00228 {
00229   return TrialDmg;
00230 }
00231 
00232 
00233 Response*
00234 NormalizedPeak::setResponse(char **argv, int argc, Information &info)
00235 {
00236 //
00237 // we compare argv[0] for known response types for the Truss
00238 //
00239   
00240   if ( strcmp(argv[0],"damage") == 0 || strcmp(argv[0],"damageindex") == 0 )
00241     return new DamageResponse( this , 1 , 0.0 );
00242   
00243   else 
00244     return 0;
00245   
00246 }
00247 
00248 int 
00249 NormalizedPeak::getResponse(int responseID, Information &info)
00250 {
00251   switch (responseID) {
00252   case -1:
00253     return -1;
00254     
00255   case 1:
00256     return info.setDouble( this->getDamage() );
00257     
00258   default:
00259     return -1;
00260   }
00261 }
00262 
00263 
00264 int
00265 NormalizedPeak::sendSelf(int commitTag, Channel &theChannel)
00266 {
00267   return 0;
00268 }
00269 
00270 
00271 int
00272 NormalizedPeak::recvSelf(int commitTag, Channel &theChannel,
00273                          FEM_ObjectBroker &theBroker)
00274 {
00275   return 0;
00276 }
00277 
00278 
00279 void
00280 NormalizedPeak::Print(OPS_Stream &s, int flag )
00281 {
00282     s << "NormalizedPeak tag: " << this->getTag() << endln;
00283     s << "  MaximumValue: " << MaxValue << " MinimumValue: " << MinValue << endln;
00284     s << " Response type: " <<damagename << endln;
00285     
00286 }

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