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

#ifndef Mesh_h
#define Mesh_h

#include "domain/mesh/MeshComponentContainer.h"
#include "utility/matrix/Vector.h"
#include "NodeLockers.h"
#include "solution/graph/graph/Graph.h"
#include "node/KDTreeNodes.h"
#include "element/utils/KDTreeElements.h"

class Pos3d;

namespace XC {
class Element;
class Node;

class ElementIter;
class NodeIter;
class SingleDomEleIter;
class SingleDomNodIter;

class Graph;
class NodeGraph;
class ElementGraph;
class FEM_ObjectBroker;
class TaggedObjectStorage;
class RayleighDampingFactors;

//
//
//
class Mesh: public MeshComponentContainer
  {
  private:
    static const double reactionValueThreshold; 
    bool eleGraphBuiltFlag;
    bool nodeGraphBuiltFlag;

    Graph theNodeGraph;
    Graph theElementGraph;

    TaggedObjectStorage *theNodes; 
    SingleDomNodIter *theNodIter; 
    KDTreeNodes kdtreeNodes; 
    std::vector<std::string> coordinateNames; 
    std::string unitsNames; 

    TaggedObjectStorage *theElements;
    SingleDomEleIter *theEleIter;
    KDTreeElements kdtreeElements; 

    Vector theBounds;
    int tagNodeCheckReactionException;

    NodeLockers lockers; 

    void alloc_containers(void);
    void alloc_iters(void);
    bool check_containers(void) const;
    void init_bounds(void);
    void update_bounds(const Vector &);
    void add_node_to_domain(Node *);
    void add_element_to_domain(Element *);
    void add_nodes_to_domain(void);
    void add_elements_to_domain(void);

    Mesh(const Mesh &other);
    Mesh &operator=(const Mesh &other);
  protected:
    void free_mem(void);
    DbTagData &getDbTagData(void) const;
    int sendData(Communicator &);
    int recvData(const Communicator &);
  public:
    Mesh(CommandEntity *owr);
    Mesh(CommandEntity *owr,TaggedObjectStorage &theNodesStorage, TaggedObjectStorage &theElementsStorage);
    Mesh(CommandEntity *owr,TaggedObjectStorage &theStorageType);
    virtual ~Mesh(void);

    // methods to populate a mesh
    virtual bool addNode(Node *);
    virtual bool removeNode(int tag);
    bool remove(Node *);

    virtual bool addElement(Element *);
    virtual bool removeElement(int tag);
    bool remove(Element *);

    virtual void clearAll(void);

    void setNodeReactionException(const int &);
    bool checkNodalReactions(const double &);

    void clearDOF_GroupPtr(void);

    void setGraphBuiltFlags(const bool &f);

    int initialize(void);
    virtual int setRayleighDampingFactors(const RayleighDampingFactors &rF);

     // methods to access the components of a mesh
    inline const TaggedObjectStorage *nodes(void) const
      { return theNodes; }
    inline TaggedObjectStorage *nodes(void)
      { return theNodes; }
    virtual NodeIter &getNodes(void);
    virtual const NodeIter &getNodes(void) const;
    int getDefaultNodeTag(void) const;
    inline const TaggedObjectStorage *elements(void) const
      { return theElements; }
    inline TaggedObjectStorage *elements(void)
      { return theElements; }
    virtual ElementIter &getElements(void);
    virtual const ElementIter &getElements(void) const;
    int getDefaultElementTag(void) const;
    inline const NodeLockers &getNodeLockers(void) const
      { return lockers; }
    inline NodeLockers &getNodeLockers(void)
      { return lockers; }

    bool existElement(int tag);
    virtual Element *getElement(int tag);
    virtual const Element *getElement(int tag) const;
    Element *getNearestElement(const Pos3d &p);
    const Element *getNearestElement(const Pos3d &p) const;
    bool existNode(int tag);
    virtual Node *getNode(int tag);
    virtual const Node *getNode(int tag) const;
    Node *getNearestNode(const Pos3d &p);
    const Node *getNearestNode(const Pos3d &p) const;

    // methods to query the state of the mesh
    virtual int getNumElements(void) const;
    virtual int getNumNodes(void) const;
    size_t getNumDeadElements(void) const;
    size_t getNumLiveElements(void) const;
    size_t getNumDeadNodes(void) const;
    size_t getNumLiveNodes(void) const;
    size_t getNumFrozenNodes(void) const;
    size_t getNumFreeNodes(void) const;
    virtual const Vector &getPhysicalBounds(void);

    inline const std::vector<std::string> &getCoordinateNames(void) const
      { return coordinateNames; }
    inline std::string getUnitsNames(void) const
      { return unitsNames; }


     // methods to get element and node graphs
    virtual int buildEleGraph(Graph &theEleGraph);
    virtual int buildNodeGraph(Graph &theNodeGraph);
    virtual Graph &getElementGraph(void);
    virtual Graph &getNodeGraph(void);

    virtual int commit(void);
    virtual int revertToLastCommit(void);
    virtual int revertToStart(void);
    int update(void);

    void freeze_dead_nodes(const std::string &nmbLocker);
    void melt_alive_nodes(const std::string &nmbLocker);

    const double getEffectiveModalMass(int mode) const;
    Vector getEffectiveModalMasses(const int &numModes) const;
    
    // mass distribution
    Matrix getTotalMass(void) const;
    double getTotalMassComponent(const int &) const;

    void zeroLoads(void);

    virtual void Print(std::ostream &s, int flag =0) const;
    friend std::ostream &operator<<(std::ostream &, const Mesh &);

    virtual int sendSelf(Communicator &);
    virtual int recvSelf(const Communicator &);
    boost::python::dict getPyDict(void) const;
    void setPyDict(const boost::python::dict &);

    // nodal methods required in mesh interface for parallel interprter
    virtual double getNodeDisp(int nodeTag, int dof, int &errorFlag);
    virtual int setMass(const Matrix &mass, int nodeTag);

    virtual int calculateNodalReactions(bool inclInertia, const double &);
    double getEigenvectorsMaxNormInf(int mode) const;
    double normalizeEigenvectors(int mode);
    boost::python::list normalizeEigenvectors(void);
    void clearEigenvectors(void);

    static void setDeadSRF(const double &);
  };

std::ostream &operator<<(std::ostream &, const Mesh &);
} // end of XC namespace

#endif