NewTemplate3Dep.h

Go to the documentation of this file.

//   COPYLEFT (C): Woody's viral GPL-like license (by BJ):
//                 ``This    source  code is Copyrighted in
//                 U.S.,  for  an  indefinite  period,  and anybody
//                 caught  using it without our permission, will be
//                 mighty good friends of ourn, cause we don't give
//                 a  darn.  Hack it. Compile it. Debug it. Run it.
//                 Yodel  it.  Enjoy it. We wrote it, that's all we
//                 wanted to do.''
//
//
// COPYRIGHT (C):     :-))
// PROJECT:           Object Oriented Finite Element Program
// FILE:              
// CLASS:             
// MEMBER FUNCTIONS:
//
// MEMBER VARIABLES
//
// PURPOSE:           
//
// RETURN:
// VERSION:
// LANGUAGE:          C++
// TARGET OS:         
// DESIGNER:          Zhao Cheng, Boris Jeremic
// PROGRAMMER:        Zhao Cheng, 
// DATE:              Fall 2005
// UPDATE HISTORY:    06/2006, add functions for matrix based elements, CZ
//                    10/2006, add various more algorithms, CZ
//                    Guanzhou Jie updated for parallel Dec 2006
//                    Feb2008 adding ScaledExplicit, Mahdi's idea
//                    Nima Tafazzoli updated for API (Feb 2009)
//





#ifndef NewTemplate3Dep_H
#define NewTemplate3Dep_H

#include <stresst.h>
#include <straint.h>
#include <BJtensor.h>
#include <BJmatrix.h>
#include <BJvector.h>
#include <Matrix.h>
#include <Vector.h>

#include <NDMaterial.h>

#include "MaterialParameter.h"
#include "ElasticState.h"
#include "YieldFunction.h"
#include "PlasticFlow.h"
#include "ScalarEvolution.h"
#include "TensorEvolution.h"
//cout
#include <G3Globals.h>

// Boris Jeremic 17Nov2008
#include <iostream>
using namespace std;



#include <Channel.h>

using namespace std;



class NewTemplate3Dep : public NDMaterial
{

public:


 


    NewTemplate3Dep( int tag,
                  MaterialParameter *ptr_material_parameter_in,
                  ElasticState      *ptr_elastic_state_in,
                  YieldFunction     *ptr_yield_function_in,        
                  PlasticFlow       *ptr_plastic_flow_in,
                  ScalarEvolution   **ptr_scalar_evolution_in,
                  TensorEvolution   **ptr_tensor_evolution_in,
                  int caseIndex_in, int subStep_in = 1);



     NewTemplate3Dep( int tag,
                  MaterialParameter *ptr_material_parameter_in,
                  ElasticState      *ptr_elastic_state_in,
                  YieldFunction     *ptr_yield_function_in,        
                  PlasticFlow       *ptr_plastic_flow_in,
                  ScalarEvolution   **ptr_scalar_evolution_in,
                  int caseIndex_in, int subStep_in = 1);



    
     NewTemplate3Dep( int tag,
                  MaterialParameter *ptr_material_parameter_in,
                  ElasticState      *ptr_elastic_state_in,
                  YieldFunction     *ptr_yield_function_in,        
                  PlasticFlow       *ptr_plastic_flow_in,
                  TensorEvolution   **ptr_tensor_evolution_in,
                  int caseIndex_in, int subStep_in = 1);





     NewTemplate3Dep( int tag,
                  MaterialParameter *ptr_material_parameter_in,
                  ElasticState      *ptr_elastic_state_in,
                  YieldFunction     *ptr_yield_function_in,        
                  PlasticFlow       *ptr_plastic_flow_in,
                  int caseIndex_in, int subStep_in = 1);
    
    NewTemplate3Dep(void);

    
    ~NewTemplate3Dep(void);

    const char *getClassType(void) const {return "NewTemplate3Dep";};

 


 
    // methods to set and retrieve state using the Matrix class, added 06/2006
    int setTrialStrain (const Vector &v);
    int setTrialStrain (const Vector &v, const Vector &r);
    int setTrialStrainIncr (const Vector &v);
    int setTrialStrainIncr (const Vector &v, const Vector &r);



    const Matrix &getTangent (void);



    const BJmatrix& getTangentBJmatrix(void);



    const Vector &getStress (void);



    const Vector &getStrain (void);

    // methods to set and retrieve state using the Tensor class    
    int setTrialStrain(const Tensor& v);
    int setTrialStrain(const Tensor& v, const Tensor& r);    
    int setTrialStrainIncr(const Tensor& v);
    int setTrialStrainIncr(const Tensor& v, const Tensor& r);



    const BJtensor& getTangentTensor(void);



    const stresstensor& getStressTensor(void);



    const straintensor& getStrainTensor(void);



    const straintensor& getPlasticStrainTensor(void);

// moved out BJ 8Jan2008
//    straintensor BardetConstraint(int , double);


    double getRho();

    int commitState(void);
    int revertToLastCommit(void);
    int revertToStart(void);
    
    NDMaterial* getCopy(void);
    NDMaterial* getCopy(const char *code);

    const char *getType(void) const;

    //Guanzhou
 int sendSelf(int commitTag, Channel &theChannel);  
    int recvSelf(int commitTag, Channel &theChannel, FEM_ObjectBroker &theBroker);

    void Print(OPS_Stream& s, int flag =0);
  
private:



    int Explicit(const straintensor& strain_incr, int NumStep_in = 1);



    int Implicit(const straintensor& strain_incr, int NumStep_in = 1);      



    int ImplicitLineSearch(const straintensor& strain_incr);



    int ScaledExplicit(const straintensor& strain_incr, int NumStep_in = 1);



    int PredictorEPState(const straintensor& strain_incr);



    stresstensor yield_surface_cross(const stresstensor& start_stress, 
                                     const stresstensor& end_stress,
         double a);



    double zbrentstress(const stresstensor& start_stress,
                        const stresstensor& end_stress,
                        double x1, double x2, double tol) const;



    double func( const stresstensor& start_stress,
                 const stresstensor& end_stress,
                 const MaterialParameter& ptr_material_parameter, 
                 double alfa ) const;




    int Tensor2MatrixSysR4(const tensor& T, Matrix& M);    



    int Tensor2VectorSysR2(const tensor& T, Vector& V);



    int Matrix2TensorSysR4(const Matrix& M, tensor& T);



    int Vector2TensorSysR2(const Vector& V, tensor& T, int Num0 = 0);

public: // temp, for test only, to be deleted



    int Stiffness2Compliance(const tensor& S, tensor& C);
 
private:




    straintensor TrialStrain;



    stresstensor TrialStress;



    straintensor TrialPlastic_Strain;


    
    stresstensor CommitStress;



    straintensor CommitStrain; 



    straintensor CommitPlastic_Strain;


  
    BJtensor Stiffness;
                
    MaterialParameter *ptr_material_parameter;
    ElasticState      *ptr_elastic_state;           
    YieldFunction     *ptr_yield_function;
    PlasticFlow       *ptr_plastic_flow;
    ScalarEvolution   **ptr_scalar_evolution;
    TensorEvolution   **ptr_tensor_evolution;
    
    int caseIndex;
    int subStep;
    int divergeOrnot;
    
    static const  straintensor ZeroStrain;
    static const  stresstensor ZeroStress;
    static const  BJtensor ZeroI4;
    static const int ISMAX;
    static const int ITMAX;
    static const double TOL;
    static const double FTOL;

    // For Matrix based elements
    static Vector sigma; 
    static Matrix D;
//BJmatrix NewTemplate3Dep::TangentMatrix( 6, 6, 0.0);
    static BJmatrix TangentMatrix;
    static Vector epsilon;
};

#endif

---