ElementBase.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/>.
//----------------------------------------------------------------------------
//ElementBase.h

#ifndef ElementBase_h
#define ElementBase_h

#include "Element.h"
#include "domain/mesh/element/utils/NodePtrsWithIDs.h"
#include "material/Material.h"
#include "domain/domain/Domain.h"
#include "utility/geom/pos_vec/Pos3d.h"
#include "utility/utils/misc_utils/colormod.h"

namespace XC {
class Node;

//
template <int NNODES>
class ElementBase: public Element
  {
  protected:
    NodePtrsWithIDs theNodes;  

    template <class TIPOMAT>
    TIPOMAT *cast_material(const Material *ptr_mat);

    int sendData(Communicator &comm);
    int recvData(const Communicator &comm);

  public:
    ElementBase(int tag, int classTag);
    ElementBase(const ElementBase &);
    ElementBase &operator=(const ElementBase &);

    static inline const int numNodes(void)
      { return NNODES; }
    // public methods to obtain information about dof & connectivity    
    int getNumExternalNodes(void) const;
    NodePtrsWithIDs &getNodePtrs(void);
    const NodePtrsWithIDs &getNodePtrs(void) const;
    Pos3d getCenterOfMassPosition(bool initialGeometry= true) const;
    

    NodePtrs::ElementConstPtrSet getConnectedElements(void) const;
    NodePtrs::ElementPtrSet getConnectedElements(void);
    boost::python::list getConnectedElementsPy(void);    
    boost::python::list getConnectedElementTags(void) const;
    
    NodePtrs::ElementConstPtrSet getConnectedElements(const SetBase *) const;
    NodePtrs::ElementPtrSet getConnectedElements(const SetBase *);
    boost::python::list getConnectedElementsPy(const SetBase *);    
    boost::python::list getConnectedElementTags(const SetBase *) const;
    
    boost::python::dict getPyDict(void) const;
    void setPyDict(const boost::python::dict &);
  };



template <int NNODES>
ElementBase<NNODES>::ElementBase(int tag, int classTag)
  : Element(tag,classTag), theNodes(this,NNODES) {}

template <int NNODES>
ElementBase<NNODES>::ElementBase(const ElementBase<NNODES> &other)
  : Element(other), theNodes(other.theNodes) 
  { theNodes.set_owner(this); }

template <int NNODES>
ElementBase<NNODES> &ElementBase<NNODES>::operator=(const ElementBase &other)
  {
    Element::operator=(other);
    theNodes= other.theNodes;
    theNodes.set_owner(this);
    return *this;
  }

template <int NNODES>
int ElementBase<NNODES>::getNumExternalNodes(void) const
  { return theNodes.size(); }

template <int NNODES>
const XC::NodePtrsWithIDs &ElementBase<NNODES>::getNodePtrs(void) const
  { return theNodes; }

template <int NNODES>
XC::NodePtrsWithIDs &ElementBase<NNODES>::getNodePtrs(void)
  { return theNodes; }

template <int NNODES> template <class TIPOMAT>
TIPOMAT *ElementBase<NNODES>::cast_material(const Material *ptr_mat)
  {
    TIPOMAT *retval= nullptr;
    if(ptr_mat)
      {
    const TIPOMAT *tmp = dynamic_cast<const TIPOMAT *>(ptr_mat);
    if(tmp)
      retval= tmp->getCopy();
    else
      {
        std::cerr << Color::red << getClassName() << "::" << __FUNCTION__
              << "; on element: " << getTag() 
              << " the material " << ptr_mat->getTag()
              << " with name: " << ptr_mat->getName()
              << " and type: " << ptr_mat->getClassName()
              << " has not a suitable type."
              << Color::def << std::endl;
        abort();
      }
    if(!retval)
      {
        std::cerr << Color::red << getClassName() << "::" << __FUNCTION__
              << "; on element: " << getTag()
              << " can't get a copy of the material with tag: "
              << ptr_mat->getTag()
              << Color::def << std::endl;
        abort();
      }
      }
    else
      {
    std::cerr << Color::red << getClassName() << "::" << __FUNCTION__
          << "; on element: " << getTag()
          << " pointer to material is null. "
          << Color::def << std::endl;
    abort();
      }
    return retval;
  }

template <int NNODES>
int ElementBase<NNODES>::sendData(Communicator &comm)
  {
    int res= Element::sendData(comm);
    res+= comm.sendMovable(theNodes,getDbTagData(),CommMetaData(6));
    return res;
  }

template <int NNODES>
int ElementBase<NNODES>::recvData(const Communicator &comm)
  {
    int res= Element::recvData(comm);
    res+= comm.receiveMovable(theNodes,getDbTagData(),CommMetaData(6));
    return res;
  }

template <int NNODES>
boost::python::dict ElementBase<NNODES>::getPyDict(void) const
  {
    boost::python::dict retval= Element::getPyDict();
    retval["nodes"]= theNodes.getPyDict();
    return retval;
  }
template <int NNODES>
void ElementBase<NNODES>::setPyDict(const boost::python::dict &d)
  {
    Element::setPyDict(d);
    theNodes.setPyDict(boost::python::extract<boost::python::dict>(d["nodes"]));
  }
  
template <int NNODES>
Pos3d ElementBase<NNODES>::getCenterOfMassPosition(bool initialGeometry) const
  { return theNodes.getCenterOfMassPosition(initialGeometry); }

template <int NNODES>
XC::NodePtrs::ElementConstPtrSet ElementBase<NNODES>::getConnectedElements(void) const
  { return theNodes.getConnectedElements(); }

template <int NNODES>
XC::NodePtrs::ElementConstPtrSet ElementBase<NNODES>::getConnectedElements(const SetBase *s) const
  { return theNodes.getConnectedElements(s); }

template <int NNODES>
XC::NodePtrs::ElementPtrSet ElementBase<NNODES>::getConnectedElements(void)
  { return theNodes.getConnectedElements(); }

template <int NNODES>
XC::NodePtrs::ElementPtrSet ElementBase<NNODES>::getConnectedElements(const SetBase *s)
  { return theNodes.getConnectedElements(s); }

template <int NNODES>
boost::python::list ElementBase<NNODES>::getConnectedElementsPy(void)
  { return theNodes.getConnectedElementsPy(); }

template <int NNODES>
boost::python::list ElementBase<NNODES>::getConnectedElementsPy(const SetBase *s)
  { return theNodes.getConnectedElementsPy(s); }


template <int NNODES>
boost::python::list ElementBase<NNODES>::getConnectedElementTags(void) const
   { return theNodes.getConnectedElementTags(); }

template <int NNODES>
boost::python::list ElementBase<NNODES>::getConnectedElementTags(const SetBase *s) const
   { return theNodes.getConnectedElementTags(s); }
  
} //end of XC namespace
#endif