Set.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/>.
//----------------------------------------------------------------------------
//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 numera(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(CommParameters &);
    int recvData(const CommParameters &);


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

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

    void clear(void);

    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_lista(const ID &);
    bool In(const Pnt *) 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_list(const ID &);
    bool In(const Edge *) 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_lst(const ID &);
    bool In(const Face *) const;
    Set pickSurfacesInside(const std::string &, const GeomObj3d &, const double &tol= 0.0);

    virtual const SetEntities::lst_ptr_cuerpos &getBodies(void) const
      { return entities.getBodies(); }
    virtual SetEntities::lst_ptr_cuerpos &getBodies(void)
      { return entities.getBodies(); }
    void setBodies(const SetEntities::lst_ptr_cuerpos &bds)
      { entities.setBodies(bds); }
    bool In(const Body *) 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(); }
    bool In(const UniformGrid *) const;

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


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

    void Transforma(const TrfGeom &trf);
    void Transforma(const size_t &indice_trf);

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

    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;

    ~Set(void);
  };
} //end of XC namespace
#endif