NLForceBeamColumn3dBase.h

// -*-c++-*-
//----------------------------------------------------------------------------
//  XC program; finite element analysis code
//  for structural analysis and design.
//
//  Copyright (C)  Luis C. 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
    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(Communicator &comm);
    int recvData(const Communicator &comm);

  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;

    const Matrix &getTangentStiff(void) const;

    const Vector &getResistingForce(void) const;

    inline double getAN1(void) const
      {
        return Secommit.AN1()+p0[0];
      }

    inline double getAN2(void) const
      {
        return Secommit.AN2();
      }

    inline double getN1(void) const
      {                 
        return -Secommit.AN1()-p0[0];
      }

    inline double getN2(void) const
      {
        return Secommit.AN2();
      }

    inline double getN(void) const
      {
        return (-Secommit.AN1()-p0[0]+Secommit.AN2())/2.0;
      }

    inline double getAMz1(void) const
      {
        return Secommit.Mz1(); 
      }

    inline double getAMz2(void) const
      {
        return Secommit.Mz2(); 
      }

    inline double getMz1(void) const
      {
        return -Secommit.Mz1(); 
      }

    inline double getMz2(void) const
      {
        return Secommit.Mz2(); 
      }

    inline double getMz(void) const
      { return (this->getMz1()+this->getMz2())/2.0; }

    inline double getVy(void) const
      {
        return -Secommit.Vy(theCoordTransf->getInitialLength()); 
      }

    inline double getAVy1(void) const
      {
        return Secommit.Vy(theCoordTransf->getInitialLength())+p0[1]; 
      }

    inline double getAVy2(void) const
      {
        return -Secommit.Vy(theCoordTransf->getInitialLength())+p0[2]; 
      }

    inline double getVy1(void) const
      {
        return this->getVy()-p0[1]; 
      }

    inline double getVy2(void) const
      {
        return p0[2]+this->getVy(); 
      }

    inline double getVz(void) const
      {
        return -Secommit.Vz(theCoordTransf->getInitialLength()); 
      }

    inline double getAVz1(void) const
      { //¡Warning! call "calc_resisting_force" before calling this method.
        return Secommit.Vz(theCoordTransf->getInitialLength())+p0[3]; 
      }

    inline double getAVz2(void) const
      {
        return -Secommit.Vz(theCoordTransf->getInitialLength())+p0[4]; 
      }

    inline double getVz1(void) const
      {
        return this->getVz()-p0[3]; 
      }

    inline double getVz2(void) const
      {
        return p0[4]+this->getVz();
      }

    inline double getMy1(void) const
      {
        return -Secommit.My1();
      }

    inline double getMy2(void) const
      {
        return Secommit.My2();
      }
    
    inline double getMy(void) const
      { return (this->getMy1()+this->getMy2())/2.0; }
    
    inline double getT(void) const
      {
        return Secommit.T();
      }

    inline double getT1(void) const
      {
        return -Secommit.T1(); //+p0[0]; 
      }

    inline double getT2(void) const
      {
        return Secommit.T2(); 
      }
    
    boost::python::list getValuesAtNodes(const std::string &, bool silent= false) const;
  };
} // end of XC namespace

#endif