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

#ifndef PAVER_H
#define PAVER_H

#include "utility/kernel/CommandEntity.h"
#include "utility/geom/d2/Polygon3d.h"

extern "C" {
#include "paving.h"
}

namespace XC {

class Paver: public CommandEntity
  {
  private:
    integer nbnode; 
    integer nprm; 
              //  (there is one outside perimeter and one perimeter for
              // each hole in the boundary)
    integer mln= 8; 
                      // number should be passed in as eight (8) currently.
    std::vector<integer> iptper; 
                                 // bnode array. Each pointer indicates the
                                 // beginning node for that perimeter in lperim.
    std::vector<integer> numper; 
                                 // nodes in each of the perimeters.
    std::vector<integer> lperim; 
    std::vector<xc_float> x; 
                         // to mxnd.
    std::vector<xc_float> y; 
                         // to mxnd.
    std::vector<xc_float> z; 
                         // to mxnd.
    std::vector<integer> iexk; 
                               // element dimensioned as (4, mxnd)
    std::vector<integer> inxe; 
                               // edge dimensioned as (2, mxnd)
    integer nnn= 0; 
    integer lll= 0; 
    integer kkk= 0; 
    integer mxnd= 0; 
                   // (if this is exceeded, noroom is returned as .true.)
    std::vector<xc_float> angle; 
                              // paving - dimensioned to (mxnd) - this becomes
                              // the angle array.
    std::vector<xc_float> bnsize; 
                              // paving - dimensioned to (mxnd * 2) - this
                              // becomes the bnsize array
    std::vector<integer> lnodes; 
                                 // paving - dimensioned to (mxnd * 8) -
                                 // this becomes the lnodes array
    std::vector<integer> linkpr; 
                                 // paving - dimensioned to (nprm * 3 -
                                 // this becomes the linkpr array
    std::vector<integer> nperim; 
                                 // paving - dimensioned to (nprm -
                                 // this becomes the nperim array
    std::vector<integer> lxk; 
                                 // paving - dimensioned to (mxnd * 4 -
                                 // this becomes the lxk array
    std::vector<integer> kxl; 
                                 // paving - dimensioned to (mxnd * 6 -
                                 // this becomes the kxl array
    std::vector<integer> nxl; 
                                 // paving - dimensioned to (mxnd * 6 -
                                 // this becomes the nxl array
    std::vector<integer> lxn; 
                                 // paving - dimensioned to (mxnd * 4 -
                                 // this becomes the lxn array
    std::vector<integer> nuid; 
                                 // paving - dimensioned to (mxnd -
                                 // this becomes the nuid array
    integer iavail= 0; 
    integer navail= 0; 
                   // becomes navail.
    logical graph= 0; 
    logical timer= 0; 
    logical video= 0; 
    xc_float defsiz= 0.0; 
                      // (set it to zero if you don't know what else to do.)
    logical sizeit= 0; 
                       // with paving.
    char dev1[3]= {' ',' ',' '}; 
                                 // describing the plotting device being used.
    integer kreg= 0; 
    logical batch= 1; 
                      // graphics capabilities.
    logical noroom= 0; 
                    // exceeded (more space is needed)
    logical err= 0; 
                 // is .true.
    std::vector<xc_float> amesur; 
                                   // (used in adaptive meshing).
    std::vector<xc_float> bmesur; 
                                   // (used in adaptive meshing).
    std::vector<xc_float> xnold; 
    std::vector<xc_float> ynold; 
    std::vector<integer> nxkold; 
                                 // (used in adaptive meshing).
    std::vector<integer> mmpold; 
    std::vector<integer> linkeg; 
    std::vector<integer> listeg; 
    integer mlink= 0; 
    integer nprold= 0; 
    integer npnold= 0; 
    integer npeold= 0; 
    integer nnxk= 0; 
    logical remesh= 0; 
    xc_float rexmin= 0.0; 
    xc_float rexmax= 0.0; 
    xc_float reymin= 0.0; 
    xc_float reymax= 0.0; 
    int idivis= 0; 
    int call_paving(const Ref2d3d &, const Polygon3d &, const std::deque<Polygon3d> &);
    int extract_mesh(const Ref2d3d &);
    std::vector<int> get_elem_nodes(const std::vector<int> &);

    // Resulting mesh.
    std::vector<Pos3d> nodePos; //Positions of the nodes.
    std::vector<std::vector<int> > elemEdges; //Element edges.
    std::deque<std::vector<int> > elemNodes; //Element nodes.
  public:
    Paver(void);
    void report(std::ostream &);
    int mesh(const Polygon3d &, const std::deque<Polygon3d> &);
    int meshPy(const Polygon3d &, const boost::python::list &);
    boost::python::list getNodePositionsPy(void) const;
    boost::python::list getQuadsPy(void) const;
    const std::vector<Pos3d> &getNodePositions(void) const;
    size_t getIndexNearestPosition(const Pos3d &, const size_t &limit) const;
    const std::deque<std::vector<int> > &getQuads(void) const;
  };

} // end of XC namespace

#endif