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

#ifndef SET_H
#define SET_H

#include "preprocessor/set_mgmt/SetMeshComp.h"
#include "preprocessor/set_mgmt/SetEntities.h"

class Pos3d;

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

class Set: public SetMeshComp
  {
  private:
    Set *alloc_set(void);
  public:
    void numerate(void);

  protected:
    std::string description; 
    SetEntities entities; 

    void clearAll(void);
    void create_copy(const std::string &,const Vector3d &v);

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


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

    inline void setDescription(const std::string &d)
      { description= d; }
    const std::string &getDescription(void) const
      { return description; }

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

    Set getEntitiesSet(void) const;
    Set getMeshComponentsSet(void) const;

    bool In(const Node *) const;
    bool isCloserThan(const Node &, const double &) const;
    bool remove(Node *);
    bool In(const Element *) const;
    bool isCloserThan(const Element &, const double &) const;
    bool remove(Element *);
    Set pickNodesInside(const std::string &, const GeomObj3d &, const double &tol= 0.0);
    Set pickNodesInside(const std::string &, const GeomObj2d &, const double &tol= 0.0);
    Set pickElemsInside(const std::string &, const GeomObj3d &, const double &tol= 0.0);
    Set pickElemsInside(const std::string &, const GeomObj2d &, const double &tol= 0.0);
    Set pickElemsCrossing(const std::string &, const GeomObj3d &, const double &tol= 0.0);
    Set pickElemsCrossing(const std::string &, const GeomObj2d &, const double &tol= 0.0);
    Set pickElemsOfType(const std::string &, const std::string &);
    Set pickElemsOfDimension(const std::string &, const size_t &);

    bool remove(Constraint *);

    virtual const SetEntities &getEntities(void) const
      { return entities; }
    virtual SetEntities &getEntities(void)
      { return entities; }
    virtual const SetMeshComp &getMeshComp(void) const
      { return *this; }
    virtual SetMeshComp &getMeshComp(void)
      { return *this; }

    virtual const SetEntities::lst_ptr_points &getPoints(void) const
      { return entities.getPoints(); }
    virtual SetEntities::lst_ptr_points &getPoints(void)
      { return entities.getPoints(); }
    void setPoints(const SetEntities::lst_ptr_points &pts)
      { entities.setPoints(pts); }
    void sel_points_from_list(const ID &);
    void selPointsFromListPy(const boost::python::list &);
    bool In(const Pnt *) const;
    bool isCloserThan(const Pnt &, const double &) const;
    Set pickPointsInside(const std::string &, const GeomObj3d &, const double &tol= 0.0);

    virtual const SetEntities::lst_line_pointers &getLines(void) const
      { return entities.getLines(); }
    virtual SetEntities::lst_line_pointers &getLines(void)
      { return entities.getLines(); }
    void setLines(const SetEntities::lst_line_pointers &lns)
      { entities.setLines(lns); }
    void sel_lines_from_list(const ID &);
    void selLinesFromListPy(const boost::python::list &);
    bool In(const Edge *) const;
    bool isCloserThan(const Edge &, const double &) const;
    Set pickLinesInside(const std::string &, const GeomObj3d &, const double &tol= 0.0);

    virtual const SetEntities::lst_surface_ptrs &getSurfaces(void) const
      { return entities.getSurfaces(); }
    virtual SetEntities::lst_surface_ptrs &getSurfaces(void)
      { return entities.getSurfaces(); }
    void setSurfaces(const SetEntities::lst_surface_ptrs &sfs)
      { entities.setSurfaces(sfs); }
    void sel_surfaces_from_list(const ID &);
    void selSurfacesFromListPy(const boost::python::list &);
    bool In(const Face *) const;
    bool isCloserThan(const Face &, const double &) const;
    Set pickSurfacesInside(const std::string &, const GeomObj3d &, const double &tol= 0.0);

    virtual const SetEntities::lst_body_pointers &getBodies(void) const
      { return entities.getBodies(); }
    virtual SetEntities::lst_body_pointers &getBodies(void)
      { return entities.getBodies(); }
    void setBodies(const SetEntities::lst_body_pointers &bds)
      { entities.setBodies(bds); }
    void sel_bodies_from_list(const ID &);
    void selBodiesFromListPy(const boost::python::list &);
    bool In(const Body *) const;
    bool isCloserThan(const Body &, const double &) const;
    Set pickBodiesInside(const std::string &, const GeomObj3d &, const double &tol= 0.0);

    virtual const SetEntities::lst_ptr_uniform_grids &getUniformGrids(void) const
      { return entities.getUniformGrids(); }
    virtual SetEntities::lst_ptr_uniform_grids &getUniformGrids(void)
      { return entities.getUniformGrids(); }
    void sel_ugrids_from_list(const ID &);
    void selUgridsFromListPy(const boost::python::list &);
    bool isCloserThan(const UniformGrid &, const double &) const;
    bool In(const UniformGrid *) const;

    BND3d Bnd(const double &) const;
    Set pickEntitiesInside(const std::string &, const GeomObj3d &, const double &tol= 0.0);
    
    void conciliaNDivs(void);
    void setUseGmsh(const bool &);
    bool getUseGmsh(void) const;
    void genMesh(meshing_dir dm);


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

    void Transform(const TrfGeom &trf);

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

    void extend(const SetEntities::lst_ptr_points &);
    void extend(const SetEntities::lst_line_pointers &);
    void extend(const SetEntities::lst_surface_ptrs &);
    void extend(const SetEntities::lst_body_pointers &);
    void extend(const SetEntities::lst_ptr_uniform_grids &);
    void extend(const Set &);
    Set &operator+=(const Set &);
    Set &operator-=(const Set &);
    Set &operator*=(const Set &);
    
    Set &operator+(const Set &) const;
    Set &operator-(const Set &) const;
    Set &operator*(const Set &) const;

    boost::python::dict getPyDict(void) const;
    void setPyDict(const boost::python::dict &);
  };
} //end of XC namespace
#endif