NLForceBeamColumn3dBase.h

//----------------------------------------------------------------------------
//  XC program; finite element analysis code
//  for structural analysis and design.
//
//  Copyright (C)  Luis Claudio Pérez Tato
//
//  This program derives from OpenSees <http://opensees.berkeley.edu>
//  developed by the  «Pacific earthquake engineering research center».
//
//  Except for the restrictions that may arise from the copyright
//  of the original program (see copyright_opensees.txt)
//  XC is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or 
//  (at your option) any later version.
//
//  This software is distributed in the hope that it will be useful, but 
//  WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details. 
//
//
// You should have received a copy of the GNU General Public License 
// along with this program.
// If not, see <http://www.gnu.org/licenses/>.
//----------------------------------------------------------------------------
//NLForceBeamColumn3dBase.h

#ifndef NLForceBeamColumn3dBase_h
#define NLForceBeamColumn3dBase_h

#include <domain/mesh/element/truss_beam_column/BeamColumnWithSectionFDTrf3d.h>
#include <utility/matrix/Matrix.h>
#include <utility/matrix/Vector.h>
#include "domain/mesh/element/utils/fvectors/FVectorBeamColumn3d.h"
#include "domain/mesh/element/truss_beam_column/EsfBeamColumn3d.h"
#include "domain/mesh/element/utils/coordTransformation/CrdTransf3d.h"

namespace XC {

//
class NLForceBeamColumn3dBase: public BeamColumnWithSectionFDTrf3d
  {
    NLForceBeamColumn3dBase &operator=(const NLForceBeamColumn3dBase &);
  protected:
    static const size_t NDM; 
    static const int NND; 
    static const size_t NEGD; 
    static const size_t NEBD; 
    static const double DefaultLoverGJ;

    
    // internal data
    double rho; 
    int maxIters; 
    double tol;  

    int initialFlag; 
    bool isTorsion;
    
    Matrix kv; 
    EsfBeamColumn3d Se; 

    Matrix kvcommit; 
    EsfBeamColumn3d Secommit; 

    std::vector<Matrix> fs; 
    std::vector<Vector> vs; 
    std::vector<Vector> Ssr; 
    std::vector<Vector> vscommit; 

    Matrix sp; 
    FVectorBeamColumn3d p0; 

    mutable Matrix Ki;

    static Matrix theMatrix;
    static Vector theVector;
    static double workArea[];

    void resizeMatrices(const size_t &nSections);
    void initializeSectionHistoryVariables(void);

    int sendData(CommParameters &cp);
    int recvData(const CommParameters &cp);

  public:
    NLForceBeamColumn3dBase(int tag,int classTag,int numSec= 0);
    NLForceBeamColumn3dBase(int tag,int classTag,int numSec,const Material *theSection,const CrdTransf *coordTransf);
    NLForceBeamColumn3dBase(const NLForceBeamColumn3dBase &);

    void setSection(const PrismaticBarCrossSection *sccModel);

    int getNumDOF(void) const;

    double getRho(void) const
      { return rho; }
    void setRho(const double &r)
      { rho= r; }

    const Matrix &getTangentStiff(void) const;

    const Vector &getResistingForce(void) const;

    inline double getAN1(void) 
      {
        return Secommit.AN1()+p0[0];
      }
    inline double getAN2(void) 
      {
        return Secommit.AN2();
      }
    inline double getN1(void) 
      {                 
        return -Secommit.AN1()-p0[0];
      }
    inline double getN2(void) 
      {
        return Secommit.AN2();
      }
    inline double getN(void) 
      {
        return (-Secommit.AN1()-p0[0]+Secommit.AN2())/2.0;
      }
    inline double getAMz1(void)
      {
        return Secommit.Mz1(); 
      }
    inline double getAMz2(void)
      {
        return Secommit.Mz2(); 
      }
    inline double getMz1(void)
      {
        return -Secommit.Mz1(); 
      }
    inline double getMz2(void)
      {
        return -Secommit.Mz2(); 
      }
    inline double getVy(void)
      {
        return Secommit.Vy(theCoordTransf->getInitialLength()); 
      }
    inline double getAVy1(void)
      {
        return Secommit.Vy(theCoordTransf->getInitialLength())+p0[1]; 
      }
    inline double getAVy2(void)
      {
        return -Secommit.Vy(theCoordTransf->getInitialLength())+p0[2]; 
      }
    inline double getVy1(void)
      {
        return -Secommit.Vy(theCoordTransf->getInitialLength())-p0[1]; 
      }
    inline double getVy2(void)
      {
        return Secommit.Vy(theCoordTransf->getInitialLength())-p0[2]; 
      }
    inline double getVz(void)
      {
        return Secommit.Vz(theCoordTransf->getInitialLength()); 
      }
    inline double getAVz1(void)
      { //¡Warning! call "calc_resisting_force" before calling this method.
        return Secommit.Vz(theCoordTransf->getInitialLength())+p0[3]; 
      }
    inline double getAVz2(void)
      {
        return -Secommit.Vz(theCoordTransf->getInitialLength())+p0[4]; 
      }
    inline double getVz1(void)
      {
        return -Secommit.Vz(theCoordTransf->getInitialLength())-p0[3]; 
      }
    inline double getVz2(void)
      {
        return Secommit.Vz(theCoordTransf->getInitialLength())-p0[4];
      }
    inline double getMy1(void)
      {
        return Secommit.My1();
      }
    inline double getMy2(void)
      {
        return Secommit.My2();
      }
    inline double getT(void) 
      {
        return Secommit.T();
      }
    inline double getT1(void)
      {
        return Secommit.T1(); //+p0[0]; 
      }
    inline double getT2(void)
      {
        return Secommit.T2(); 
      }

  };
} // end of XC namespace

#endif