GeneratedMesh.hpp

/*------------------------------------------------------------------------*/
/*                 Copyright 2010 Sandia Corporation.                     */
/*  Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive   */
/*  license for use of this work by or on behalf of the U.S. Government.  */
/*  Export of this program may require a license from the                 */
/*  United States Government.                                             */
/*------------------------------------------------------------------------*/

#ifndef STK_IO_UTIL_GENERATEDMESH_HPP
#define STK_IO_UTIL_GENERATEDMESH_HPP
#include <string>
#include <vector>

namespace stk_classic {
  namespace io {
    namespace util {
      class GeneratedMesh
      {
      public:
  enum ShellLocation {MX =  0,  PX =  1,
          MY =  2,  PY =  3,
          MZ =  4,  PZ =  5};

  explicit GeneratedMesh(const std::string &parameters, int proc_count = 1, int my_proc = 0);
  GeneratedMesh(int num_x, int num_y, int num_z,        int proc_count = 1, int my_proc = 0);
  ~GeneratedMesh();

  size_t add_shell_block(ShellLocation loc);
    
  size_t add_nodeset(ShellLocation loc);
    
  size_t add_sideset(ShellLocation loc);
    
  void set_scale(double scl_x, double scl_y, double scl_z);
  void set_offset(double off_x, double off_y, double off_z);
  void set_bbox(double xmin, double ymin, double zmin,
          double xmax, double ymax, double zmax);
  
  void set_rotation(const std::string &axis, double angle_degrees);

  size_t node_count() const;

  size_t node_count_proc() const;

  size_t block_count() const;

  size_t nodeset_count() const;

  size_t nodeset_node_count(size_t id) const;

  size_t nodeset_node_count_proc(size_t id) const;

  size_t sideset_count() const;

  size_t sideset_side_count(size_t id) const;

  size_t sideset_side_count_proc(size_t id) const;

  size_t element_count() const;

  size_t shell_element_count(ShellLocation) const;

  size_t element_count_proc() const;

  size_t shell_element_count_proc(ShellLocation) const;

  size_t element_count(size_t block_number) const;

  size_t element_count_proc(size_t block_number) const;

  std::pair<std::string, int>  topology_type(size_t block_number) const;
    
  size_t communication_node_count_proc() const;
  void node_communication_map(std::vector<int> &map, std::vector<int> &proc);
    
  void node_map(std::vector<int> &map);

  void element_map(size_t block_number, std::vector<int> &map) const;

  void element_map(std::vector<int> &map) const;
    
  void element_surface_map(ShellLocation loc, std::vector<int> &map) const;
    
  void connectivity(size_t block_number, std::vector<int> &connect) const;

  void coordinates(std::vector<double> &coord) const;

  void coordinates(std::vector<double> &x,
       std::vector<double> &y,
       std::vector<double> &z) const;
    
  void nodeset_nodes(size_t nset_id, std::vector<int> &nodes) const;

  void sideset_elem_sides(size_t nset_id, std::vector<int> &elem_sides) const;

      private:
    
  GeneratedMesh( const GeneratedMesh & );
  GeneratedMesh & operator = ( const GeneratedMesh & );

  void parse_options(const std::vector<std::string> &groups);
  void show_parameters() const;
  void initialize();
  
        std::vector<ShellLocation> shellBlocks;
  std::vector<ShellLocation> nodesets;
  std::vector<ShellLocation> sidesets;
        double rotmat[3][3];
  size_t numX, numY, numZ;
  size_t myNumZ, myStartZ;

  size_t processorCount;
  size_t myProcessor;

  double offX, offY, offZ; 
  double sclX, sclY, sclZ; 
  bool doRotation;
      };
    }
  }
}
#endif