PressureIndependMultiYield.h

Go to the documentation of this file.
00001 // $Revision: 1.17 $
00002 // $Date: 2006/08/04 18:29:48 $
00003 // $Source: /usr/local/cvs/OpenSees/SRC/material/nD/soil/PressureIndependMultiYield.h,v $
00004                                                                         
00005 // Written: ZHY
00006 // Created: August 2000
00007 
00008 // Description: This file contains the class prototype for PressureIndependMultiYield.
00009 //
00010 // What: "@(#) PressureIndependMultiYield.h, revA"
00011 
00012 #ifndef PressureIndependMultiYield_h
00013 #define PressureIndependMultiYield_h
00014 
00015 #include <NDMaterial.h>
00016 #include <MultiYieldSurface.h>
00017 #include <Matrix.h>
00018 #include <Tensor.h>
00019 
00020 class PressureIndependMultiYield : public NDMaterial
00021 {
00022 public:
00023      // Initialization constructor
00024      PressureIndependMultiYield (int tag, 
00025                                  int nd,
00026                                  double rho, 
00027                                  double refShearModul,
00028                                  double refBulkModul,
00029                                  double cohesi,
00030                                  double peakShearStra,
00031                                  double frictionAng = 0.,
00032                                  double refPress = 100, 
00033                                  double pressDependCoe = 0.0,
00034                                  int   numberOfYieldSurf = 20,
00035                                  double * gredu = 0);
00036 
00037      // Default constructor
00038      PressureIndependMultiYield ();
00039 
00040      // Copy constructor
00041      PressureIndependMultiYield (const PressureIndependMultiYield &);
00042 
00043      // Destructor: clean up memory storage space.
00044      virtual ~PressureIndependMultiYield ();
00045 
00046      const char *getClassType(void) const {return "PressureIndependMultiYield";};
00047 
00048      double getRho(void) {return rhox[matN];} ;
00049      // Sets the values of the trial strain tensor.
00050      int setTrialStrain (const Vector &strain);
00051 
00052      // Sets the values of the trial strain and strain rate tensors.
00053      int setTrialStrain(const Vector &v, const Vector &r);
00054 
00055      int setTrialStrainIncr(const Vector &v);
00056      int setTrialStrainIncr(const Vector &v, const Vector &r);
00057 
00058      // Calculates current tangent stiffness.
00059      const Matrix &getTangent (void);
00060      const Matrix &getInitialTangent (void);
00061         
00062      void getBackbone (Matrix &);
00063 
00064      // Calculates the corresponding stress increment (rate), for a given strain increment. 
00065      const Vector &getStress (void);
00066      const Vector &getStrain (void);
00067      const Vector &getCommittedStress (void);
00068      const Vector &getCommittedStrain (void);
00069 
00070      int setTrialStrain (const Tensor &v) {return 0;}
00071      int setTrialStrain (const Tensor &v, const Tensor &r) {return 0;}
00072      int setTrialStrainIncr (const Tensor &v) {return 0;}
00073      int setTrialStrainIncr (const Tensor &v, const Tensor &r) {return 0;}
00074 
00075      // Accepts the current trial strain values as being on the solution path, and updates 
00076      // all model parameters related to stress/strain states. Return 0 on success.
00077      int commitState (void);
00078 
00079      // Revert the stress/strain states to the last committed states. Return 0 on success.
00080      int revertToLastCommit (void);
00081 
00082      int revertToStart(void) {return 0;}
00083 
00084      // Return an exact copy of itself.
00085      NDMaterial *getCopy (void);
00086 
00087      // Return a copy of itself if "code"="PressureIndependMultiYield", otherwise return null.
00088      NDMaterial *getCopy (const char *code);
00089 
00090      // Return the string "PressureIndependMultiYield".
00091      const char *getType (void) const ;
00092 
00093      // Return ndm.
00094      int getOrder (void) const ;
00095 
00096      int sendSelf(int commitTag, Channel &theChannel);  
00097      int recvSelf(int commitTag, Channel &theChannel, 
00098                   FEM_ObjectBroker &theBroker);    
00099 
00100      Response *setResponse (const char **argv, int argc, Information &matInfo, OPS_Stream &s);
00101      int getResponse (int responseID, Information &matInformation);
00102      void Print(OPS_Stream &s, int flag =0);
00103 
00104      //void setCurrentStress(const Vector stress) { currentStress=T2Vector(stress); }
00105      int updateParameter(int responseID, Information &eleInformation);  
00106 
00107     // RWB; PyLiq1 & TzLiq1 need to see the excess pore pressure and initial stresses.
00108     friend class PyLiq1;
00109     friend class TzLiq1;
00110 
00111 protected:
00112 
00113 private:
00114 
00115         static int matCount;
00116         static int* loadStagex;  //=0 if elastic; =1 if plastic
00117 
00118   // user supplied
00119         static int* ndmx;  //num of dimensions (2 or 3)
00120         static double* rhox;
00121         static double* frictionAnglex;
00122         static double* peakShearStrainx;
00123         static double* refPressurex;
00124         static double* cohesionx;
00125         static double* pressDependCoeffx;
00126         static int*    numOfSurfacesx;
00127 
00128         // internal
00129         static double* residualPressx;
00130         static Matrix theTangent;  //classwise member
00131         int e2p;
00132         int matN;
00133         double refShearModulus;
00134         double refBulkModulus;
00135         MultiYieldSurface * theSurfaces; // NOTE: surfaces[0] is not used  
00136         MultiYieldSurface * committedSurfaces;  
00137         int    activeSurfaceNum;  
00138         int    committedActiveSurf;
00139         T2Vector currentStress;
00140         T2Vector trialStress;
00141         T2Vector currentStrain;
00142         T2Vector strainRate;
00143         static T2Vector subStrainRate;
00144 
00145         void elast2Plast(void);
00146         // Called by constructor
00147         void setUpSurfaces(double *);  
00148 
00149         double yieldFunc(const T2Vector & stress, const MultiYieldSurface * surfaces, 
00150                          int surface_num);
00151 
00152         void deviatorScaling(T2Vector & stress, const MultiYieldSurface * surfaces, 
00153                              int surfaceNum, int count=0);
00154 
00155         void initSurfaceUpdate(void);
00156 
00157         void paramScaling(void);
00158 
00159         // Return num_strain_subincre
00160         int setSubStrainRate(void);
00161 
00162         int isLoadReversal(void);
00163 
00164         void getContactStress(T2Vector &contactStress);
00165 
00166         void getSurfaceNormal(const T2Vector & stress, Vector &surfaceNormal); 
00167 
00168         void setTrialStress(T2Vector & stress); 
00169 
00170         double getLoadingFunc(const T2Vector & contact, 
00171                               const Vector & surfaceNormal,int crossedSurface);
00172 
00173         void stressCorrection(int crossedSurface);
00174         
00175         void updateActiveSurface(void);
00176         
00177         void updateInnerSurface(void);
00178 
00179         // Return 1 if crossing the active surface; return 0 o/w
00180         int  isCrossingNextSurface(void);  
00181 
00182 };
00183 
00184 #endif
00185 
00186 
00187 
00188 
00189 
00190 
00191 

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