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

#ifndef SETMESHCOMP_H
#define SETMESHCOMP_H

#include "SetBase.h"
#include "DqPtrs.h"
#include "DqPtrsNode.h"
#include "DqPtrsElem.h"
#include "DqPtrsConstraint.h"
#include <set>

class Pos3d;
class SlidingVectorsSystem3d;
class Plane;

namespace XC {
class TrfGeom;
class SFreedom_Constraint;
class ID;
class Element;
class Node;
class Constraint;

class SetMeshComp: public SetBase
  {
  protected:
    template <class L>
    static void numerate_list(L &l);
    void numerate(void);
  public:
    //Nodes.
    typedef DqPtrsNode::iterator nod_iterator; 
    typedef DqPtrsNode::const_iterator nod_const_iterator; 

    //Elements.
    typedef DqPtrsElem::iterator elem_iterator; 
    typedef DqPtrsElem::const_iterator elem_const_iterator; 

    //Constraints.
    typedef DqPtrsConstraint lst_ptr_constraints; 
    typedef DqPtrsConstraint::iterator constraint_iterator; 
    typedef DqPtrsConstraint::const_iterator constraint_const_iterator; 

  private:
    DqPtrsNode nodes; 
    DqPtrsElem elements; 
    lst_ptr_constraints constraints; 

  protected:
    void extend_lists(const SetMeshComp &);
    void substract_lists(const SetMeshComp &);
    void intersect_lists(const SetMeshComp &);
    void copy_lists(const SetMeshComp &);
    
    void clearAll(void);

    DbTagData &getDbTagData(void) const;
    int sendData(Communicator &);
    int recvData(const Communicator &);


    void calc_resisting_force(void);

    void move(const Vector3d &);
  public:
    SetMeshComp(const std::string &nmb="",Preprocessor *preprocessor= nullptr);
    SetMeshComp(const SetMeshComp &);
    ~SetMeshComp(void);
    
    SetMeshComp &operator=(const SetMeshComp &);
    SetMeshComp &operator+=(const SetMeshComp &);
    SetMeshComp &operator-=(const SetMeshComp &);
    SetMeshComp &operator*=(const SetMeshComp &);

    void extend(const DqPtrsNode &);
    void extend(const DqPtrsElem &);
    void extend(const lst_ptr_constraints &);
    void extend(const SetMeshComp &);
    void substract(const DqPtrsNode &);
    void substract(const DqPtrsElem &);
    void substract(const lst_ptr_constraints &);
    void substract(const SetMeshComp &);
    
    std::string getStrName(void) const;
    void newName(const std::string &);
    void rename(const std::string &);
    
    size_t getNumberOfNodes(void) const
      { return nodes.size(); }
    void addNode(Node *nPtr);
    virtual const DqPtrsNode &getNodes(void) const
      { return nodes; }
    virtual DqPtrsNode &getNodes(void)
      { return nodes; }
    void setNodes(const DqPtrsNode &nds)
      { nodes= nds; }
    void clearNodes(void)
      { nodes.clearAll(); }
    void sel_nodes_from_list(const ID &);
    bool In(const Node *) const;
    bool isCloserThan(const Pos3d &, const double &) const;
    bool remove(Node *);
    SetMeshComp pickNodesInside(const std::string &, const GeomObj3d &, const double &tol= 0.0);
    SetMeshComp pickNodesInside(const std::string &, const GeomObj2d &, const double &tol= 0.0);
    BND3d Bnd(const double &) const;
    PrincipalAxes3D getOrientation(const double &) const;

    size_t getNumberOfElements(void) const
      { return elements.size(); }
    void addElement(Element *);
    virtual const DqPtrsElem &getElements(void) const
      { return elements; }
    virtual DqPtrsElem &getElements(void)
      { return elements; }
    void setElements(const DqPtrsElem &els)
      { elements= els; }
    void clearElements(void)
      { elements.clearAll(); }
    void sel_elements_from_list(const ID &tags);
    bool In(const Element *) const;
    bool isCloserThan(const GeomObj::list_Pos3d &, const double &) const;
    bool remove(Element *);
    SetMeshComp pickElemsInside(const std::string &, const GeomObj3d &, const double &tol= 0.0);
    SetMeshComp pickElemsInside(const std::string &, const GeomObj2d &, const double &tol= 0.0);
    SetMeshComp pickElemsCrossing(const std::string &, const GeomObj3d &, const double &tol= 0.0);
    SetMeshComp pickElemsCrossing(const std::string &, const GeomObj2d &, const double &tol= 0.0);
    SetMeshComp pickElemsOfType(const std::string &, const std::string &);
    SetMeshComp pickElemsOfDimension(const std::string &, const size_t &);
    inline boost::python::list getElementTypesPy(void) const
      { return elements.getTypesPy(); }
    inline boost::python::list getElementDimensionsPy(void) const
      { return elements.getDimensionsPy(); }
    inline boost::python::list getElementMaterialNamesPy(void) const
      { return elements.getMaterialNamesPy(); }
    SetMeshComp pickElemsOfMaterial(const std::string &, const std::string &);

    size_t getNumberOfConstraints(void) const
      { return constraints.size(); }
    void addConstraint(Constraint *);
    bool remove(Constraint *);
    virtual const DqPtrsConstraint &getConstraints(void) const
      { return constraints; }
    virtual DqPtrsConstraint &getConstraints(void)
      { return constraints; }
    void setConstraints(const DqPtrsConstraint &cts)
      { constraints= cts; }
    void clearConstraints(void)
      { constraints.clearAll(); }
    bool In(const Constraint *) const;
    void sel_constraints_from_list(const ID &tags, const ID &types);

    void appendFromGeomEntity(const SetBase &);

    void clear(void);
    bool empty(void) const;    

    void fix(const SFreedom_Constraint &);

    //nod_iterator nodes_begin(void);
    nod_const_iterator nodes_begin(void) const;
    //nod_iterator nodes_end(void);
    nod_const_iterator nodes_end(void) const;
    Node *findNode(const int &tag);
    const Node *findNode(const int &tag) const;
    bool InNodeTag(const int) const;
    bool InNodeTags(const ID &) const;
    std::set<int> getNodeTags(void) const;
    std::set<int> getElementTags(void) const;
    std::set<int> getConstraintTags(void) const;
    Node *getNearestNode(const Pos3d &p);
    const Node *getNearestNode(const Pos3d &p) const;


    elem_iterator elem_begin(void);
    elem_const_iterator elem_begin(void) const;
    elem_iterator elem_end(void);
    elem_const_iterator elem_end(void) const;
    Element *findElement(const int &);
    const Element *findElement(const int &) const;
    Element *getNearestElement(const Pos3d &);
    const Element *getNearestElement(const Pos3d &) const;

    void kill_elements(void);
    void alive_elements(void);
    size_t getNumDeadElements(void) const;
    size_t getNumLiveElements(void) const;
    size_t getNumDeadNodes(void) const;
    size_t getNumLiveNodes(void) const;

    constraint_iterator constraints_begin(void);
    constraint_const_iterator constraints_begin(void) const;
    constraint_iterator constraints_end(void);
    constraint_const_iterator constraints_end(void) const;
    Constraint *buscaConstraint(const int &tag);
    const Constraint *buscaConstraint(const int &tag) const;

    void fillUpwards(void);
    void fillDownwards(void);

    virtual void Transform(const TrfGeom &trf);

    SlidingVectorsSystem3d getResistingSlidingVectorsSystem3d(const Plane &,const Pos3d &,const double &,const bool &) const;
    Matrix getTangentStiff(const Node &);
    Matrix getInitialStiff(const Node &);

    boost::python::list createInertiaLoads(const Vector &);
    
    // mass distribution
    Matrix getTotalMass(void) const;
    double getTotalMassComponent(const int &) const;

    virtual int sendSelf(Communicator &);
    virtual int recvSelf(const Communicator &);

    SetMeshComp operator+(const SetMeshComp &) const;
    SetMeshComp operator-(const SetMeshComp &) const;
    SetMeshComp operator*(const SetMeshComp &) const;

    boost::python::dict getPyDict(void) const;
    void setPyDict(const boost::python::dict &);
  };


template <class L>
void XC::SetMeshComp::numerate_list(L &l)
  {
    size_t idx= 0;
    typedef typename L::iterator iterator;
    typedef typename L::reference reference;
    for(iterator i= l.begin();i!=l.end();i++,idx++)
      {
    reference ptr= *i;
        ptr->set_index(idx);
      }
  }

} //end of XC namespace
#endif