geometry.hpp

Go to the documentation of this file.

 
/* Copyright (c) 2005-2013,2019 Taneli Kalvas. All rights reserved.
 *
 * You can redistribute this software and/or modify it under the terms
 * of the GNU General Public License as published by the Free Software
 * Foundation; either version 2 of the License, or (at your option)
 * any later version.
 * 
 * This library 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 library (file "COPYING" included in the package);
 * if not, write to the Free Software Foundation, Inc., 51 Franklin
 * Street, Fifth Floor, Boston, MA 02110-1301 USA
 * 
 * If you have questions about your rights to use or distribute this
 * software, please contact Berkeley Lab's Technology Transfer
 * Department at TTD@lbl.gov. Other questions, comments and bug
 * reports should be sent directly to the author via email at
 * taneli.kalvas@jyu.fi.
 * 
 * NOTICE. This software was developed under partial funding from the
 * U.S.  Department of Energy.  As such, the U.S. Government has been
 * granted for itself and others acting on its behalf a paid-up,
 * nonexclusive, irrevocable, worldwide license in the Software to
 * reproduce, prepare derivative works, and perform publicly and
 * display publicly.  Beginning five (5) years after the date
 * permission to assert copyright is obtained from the U.S. Department
 * of Energy, and subject to any subsequent five (5) year renewals,
 * the U.S. Government is granted for itself and others acting on its
 * behalf a paid-up, nonexclusive, irrevocable, worldwide license in
 * the Software to reproduce, prepare derivative works, distribute
 * copies to the public, perform publicly and display publicly, and to
 * permit others to do so.
 */
 
#ifndef GEOMETRY_HPP
#define GEOMETRY_HPP 1
 
 
#include <stdint.h>
#include <pthread.h>
#include <vector>
#include <iostream>
#include "file.hpp"
#include "vec3d.hpp"
#include "vtriangle.hpp"
#include "solid.hpp"
#include "mesh.hpp"
#include "types.hpp"
#include "callback.hpp"
 
 
class Bound 
{
    bound_e                   _type;    
    double                    _value;   
    const CallbackFunctorD_V *_functor; 
public:
 
    Bound( bound_e type, double value );
 
    Bound( bound_e type, const CallbackFunctorD_V *functor );
 
    Bound( std::istream &is );
 
    bound_e type( void ) const;
 
    void set_value( double value );
 
    double value( void ) const;
 
    double value( const Vec3D &x ) const;
 
    bool is_constant() const;
 
    void save( std::ostream &os ) const;
 
    friend std::ostream &operator<<( std::ostream &os, const Bound &b );
};
 
 
#define SMESH_NODE_ID_MASK             0xE0000000 // 111...
 
#define SMESH_NODE_ID_PURE_VACUUM      0x00000000 // 000...
#define SMESH_NODE_ID_NEAR_SOLID       0x20000000 // 001...
#define SMESH_NODE_ID_NEUMANN          0x40000000 // 010...
#define SMESH_NODE_ID_ROUGH_BOUNDARY   0x60000000 // 011...
 
#define SMESH_NODE_ID_PURE_VACUUM_FIX  0x80000000 // 100...
#define SMESH_NODE_ID_NEAR_SOLID_FIX   0xA0000000 // 101...
#define SMESH_NODE_ID_DIRICHLET        0xC0000000 // 110...
#define SMESH_NODE_ID_FINE_BOUNDARY    0xE0000000 // 111...
 
#define SMESH_NODE_FIXED               0x80000000 // 100...
 
 
#define SMESH_BOUNDARY_NUMBER_MASK     0x000000FF // limit to 0-255
#define SMESH_NEAR_SOLID_INDEX_MASK    0x1FFFFFFF // limit to 0-2^29 (5.4e8)
 
 
class Geometry : public Mesh
{
    struct BuildMeshData {
        pthread_t  thread;
        uint32_t   index;
        Geometry  *geom;
    };
 
    uint32_t                   _n;         
    std::vector<const Solid*>  _sdata;     
    std::vector<Bound>         _bound;     
    bool                       _built;     
    uint32_t                  *_smesh;     
    std::vector<uint8_t>       _nearsolid; 
    pthread_mutex_t            _mutex;     
    pthread_cond_t             _cond;      
    uint32_t                   _done;      
    double                     _surface_eps; 
    VTriangleSurface           _surface;   
    std::vector<int32_t>       _triptr;    
    uint32_t is_solid( int32_t i, int32_t j, int32_t k ) const;
 
    void add_near_solid_entry( uint32_t &near_solid_index, int32_t i, int32_t j, int32_t k );
 
    uint8_t bracket_ndist( int32_t i, int32_t j, int32_t k, int32_t solid, int sign, int coord ) const;
 
    void check_definition();
 
    Vec3D surface_normal_2d( const Vec3D &x ) const;
    Vec3D surface_normal_3d( const Vec3D &x ) const;
 
 
    void build_mesh_parallel_near_solid( uint32_t ind, int32_t i, int32_t j, int32_t k );
    void build_mesh_parallel_prepare_near_solid( uint32_t &near_solid_index, 
                                                 int32_t i, int32_t j, int32_t k );
    void build_mesh_parallel_prepare_3d( void );
    void build_mesh_parallel_prepare_2d( void );
    void build_mesh_parallel_prepare_1d( void );
 
    void build_mesh_parallel_thread_3d( BuildMeshData *bmd );
    void build_mesh_parallel_thread_2d( BuildMeshData *bmd );
    void build_mesh_parallel_thread_1d( void );
    void build_mesh_parallel_thread( BuildMeshData *bmd );
 
    static void *build_mesh_parallel_entry( void *data );
    void build_mesh_parallel( void );
 
    static const int32_t mc_faces[15*256];
 
    Vec3D mc_surface( int32_t i, int32_t j, int32_t k, uint8_t cn, int32_t ei ) const;
    uint8_t mc_case( int32_t i, int32_t j, int32_t k ) const;
    uint32_t mc_trianglec( uint8_t cn ) const;
    int32_t mc_add_vertex_try( const Vec3D &x, int32_t i, int32_t j, int32_t k ) const;
    uint32_t mc_add_vertex( const Vec3D &x, int32_t i, int32_t j, int32_t k, uint32_t firstv );
    void mc_triangulate( int32_t i, int32_t j, int32_t k );
 
    uint8_t surface_cell_face_case_2d( const int32_t i[3], const int32_t vb[3] ) const;
    double surface_cell_face_dist( const int32_t i[3], const int32_t vb[3], 
                                   int32_t dx, int32_t dy, 
                                   int32_t dir ) const;
    uint32_t surface_cell_face_add_vertex( VTriangleSurfaceSolid &solid,
                                           const int32_t i[3], const int32_t vb[3], 
                                           double dx, double dy ) const;
    void surface_cell_face_add_triangles( VTriangleSurfaceSolid &solid,
                                          int32_t i0, int32_t i1, int32_t i2, 
                                          int32_t vb0, int32_t vb1, int32_t vb2 ) const;
    void surface_cell_face_add_triangles( VTriangleSurfaceSolid &solid,
                                          const int32_t i[3], const int32_t vb[3] ) const;
    uint32_t surface_inside_solid_number( int32_t i, int32_t j,int32_t k ) const;
 
public:
 
    Geometry( geom_mode_e geom_mode, Int3D size, Vec3D origo, double h );
 
    explicit Geometry( std::istream &is );
 
    ~Geometry();
 
    uint32_t number_of_solids() const;
 
    uint32_t number_of_boundaries() const;
    
    void set_solid( uint32_t n, const Solid *s );
 
    const Solid *get_solid( uint32_t n ) const;
 
    void set_boundary( uint32_t n, const Bound &b );
 
    Bound get_boundary( uint32_t n ) const;
 
    std::vector<Bound> get_boundaries() const;
 
    bool have_solid_data( void ) const;
 
    uint32_t inside( const Vec3D &x ) const;
 
    bool inside( uint32_t n, const Vec3D &x ) const;
 
    double bracket_surface( uint32_t n, const Vec3D &xin, const Vec3D &xout, Vec3D &xsurf ) const;
 
    Vec3D surface_normal( const Vec3D &x ) const;
 
    bool built( void ) const { return( _built ); }
 
    void build_mesh( void );
 
    const uint32_t &mesh( int32_t i ) const { return( _smesh[i] ); }
 
    const uint32_t &mesh( int32_t i, int32_t j ) const {
        return( _smesh[i + j*_size[0]] ); 
    }
 
    const uint32_t &mesh( int32_t i, int32_t j, int32_t k ) const {
        return( _smesh[i + j*_size[0] + k*_size[0]*_size[1]] );
    }
 
    uint32_t &mesh( int32_t i ) { return( _smesh[i] ); }
 
    uint32_t &mesh( int32_t i, int32_t j ) {
        return( _smesh[i + j*_size[0]] );
    }
 
    uint32_t &mesh( int32_t i, int32_t j, int32_t k ) {
        return( _smesh[i + j*_size[0] + k*_size[0]*_size[1]] );
    }
 
    uint32_t mesh_check( int32_t i ) const;
 
    uint32_t mesh_check( int32_t i, int32_t j ) const;
 
    uint32_t mesh_check( int32_t i, int32_t j, int32_t k ) const;
 
    bool is_near_solid( int32_t i, int32_t j, int32_t k ) const;
 
    const uint8_t *nearsolid_ptr( int32_t index ) const {
        return( &_nearsolid[index] );
    }
 
    uint8_t solid_dist( uint32_t i, uint32_t j, uint32_t k, uint32_t dir ) const;
 
    uint8_t solid_dist( uint32_t i, uint32_t dir ) const;
 
    void build_surface( void );
    
    bool surface_built( void ) const { return( _triptr.size() ); }
 
    uint32_t surface_inside( const Vec3D &x ) const;
 
    uint32_t surface_vertexc( void ) const {
        return( _surface.vertexc() );
    }
 
    uint32_t surface_trianglec( void ) const {
        return( _surface.trianglec() );
    }
 
    const Vec3D &surface_vertex( int32_t a ) const {
        return( _surface.vertex(a) );
    }
 
    Vec3D surface_triangle_normal( const Vec3D &x ) const;
 
    Vec3D surface_triangle_normal( int32_t a ) const;
 
    const VTriangle &surface_triangle( int32_t a ) const {
        return( _surface.triangle(a) );
    }
 
    uint32_t surface_triangle_ptr( int32_t i, int32_t j, int32_t k ) const {
        return( _triptr[(k*(_size[1]-1) + j)*(_size[0]-1) + i] );
    }
 
    int32_t surface_trianglec( int32_t i, int32_t j, int32_t k ) const;
 
    void save( const std::string &filename, bool save_solids = false ) const;
 
    void save( std::ostream &os, bool save_solids = false ) const;
 
    void debug_print( std::ostream &os ) const;
};
 
 
#endif