MC_grid_3d.hpp

Go to the documentation of this file.

#ifndef _MC_GRID_3D_HPP_
#define _MC_GRID_3D_HPP_

#include <MC_int_vector.hpp>
#include <MC_int_vector_vector.hpp>
#include <MC_exception.hpp>
#include <MC_string_helper.hpp>

#include <vector>
#include <algorithm>

namespace mesh_conv
{

    namespace exception
    {
        class MC_exception_grid_3d : public MC_exception
        {
        public:
            MC_exception_grid_3d(const std::string& message):MC_exception(message){}
        private:
        };

        class MC_exception_grid_3d_out_of_bounds : public MC_exception_grid_3d
        {
        public:
            MC_exception_grid_3d_out_of_bounds(const std::string& message):MC_exception_grid_3d(message){}
        private:
        };
    }



    template <typename VALUE>
            class MC_grid_3d
    {
    public:

        // ************************************************ //
        // ************************************************ //
        // Constructor
        // ************************************************ //
        // ************************************************ //

        MC_grid_3d();
        MC_grid_3d(const MC_int_vector& given_size);


        // ************************************************ //
        // ************************************************ //
        // Size
        // ************************************************ //
        // ************************************************ //

        const MC_int_vector& size() const;


        // ************************************************ //
        // ************************************************ //
        // Get/Set value
        // ************************************************ //
        // ************************************************ //

        VALUE& get(const MC_int_vector& X);
        const VALUE& get(const MC_int_vector& X) const;
        std::vector<VALUE> get(const MC_int_vector_vector& X) const;

        void set(const MC_int_vector& X,const VALUE& y);



        void fill(const VALUE& y);




    private:

        std::vector<VALUE> grid;
        MC_int_vector dimension;


        void assert_is_in_range(const MC_int_vector& X) const throw(exception::MC_exception_grid_3d_out_of_bounds);


    };
}




namespace mesh_conv
{
    template <typename VALUE>
            MC_grid_3d<VALUE>::MC_grid_3d(const MC_int_vector& given_size)
    {
        if(given_size.size()!=3)
        {
            std::cout<<"Error in MC_grid_3d() size dim must be 3 and not "<<given_size.size()<<std::endl;
            throw exception::MC_exception_grid_3d("Error in MC_grid_3d size dim must be 3");
        }

        grid.resize(given_size[0]*given_size[1]*given_size[2]);
        dimension=given_size;
    }

    template <typename VALUE>
            const MC_int_vector& MC_grid_3d<VALUE>::size() const
    {return dimension;}

    template <typename VALUE>
            VALUE& MC_grid_3d<VALUE>::get(const MC_int_vector& X)
    {
        if(X.size()!=3)
        {
            std::cout<<"Error in MC_grid_3d::get size position must be 3 and not "<<X.size()<<std::endl;
            throw exception::MC_exception_grid_3d("Error in MC_grid_3d::get size position must be 3");
        }

        assert_is_in_range(X);
        return grid[X[0]+dimension[0]*(X[1]+dimension[1]*X[2])];
    }

    template <typename VALUE>
            const VALUE& MC_grid_3d<VALUE>::get(const MC_int_vector& X) const
    {
        if(X.size()!=3)
        {
            std::cout<<"Error in MC_grid_3d::get size position must be 3 and not "<<X.size()<<std::endl;
            throw exception::MC_exception_grid_3d("Error in MC_grid_3d::get size position must be 3");
        }
        assert_is_in_range(X);

        return grid[X[0]+dimension[0]*(X[1]+dimension[1]*X[2])];
    }

    template <typename VALUE>
            std::vector<VALUE> MC_grid_3d<VALUE>::get(const MC_int_vector_vector& X) const
    {
        std::vector<VALUE> vec;
        for(unsigned int k=0,N=X.size();k<N;++k)
            vec.push_back(get(X[k]));
        return vec;
    }

    template <typename VALUE>
            void MC_grid_3d<VALUE>::set(const MC_int_vector& X,const VALUE& y)
    {
        if(X.size()!=3)
        {
            std::cout<<"Error in MC_grid_3d::get size position must be 3 and not "<<X.size()<<std::endl;
            throw exception::MC_exception_grid_3d("Error in MC_grid_3d::get size position must be 3");
        }
        assert_is_in_range(X);
        grid[X[0]+dimension[0]*(X[1]+dimension[1]*X[2])]=y;
    }

    template <typename VALUE>
            void MC_grid_3d<VALUE>::assert_is_in_range(const MC_int_vector& X) const throw(exception::MC_exception_grid_3d_out_of_bounds)
    {
        if(X[0]<0 || X[0]>=dimension[0])
            throw exception::MC_exception_grid_3d_out_of_bounds("Error in MC_grid_3d::assert_is_in_range, try to access x="+MC_string_converter::to_string(X[0])+"/"+MC_string_converter::to_string(dimension[0]));
        if(X[1]<0 || X[1]>=dimension[1])
            throw exception::MC_exception_grid_3d_out_of_bounds("Error in MC_grid_3d::assert_is_in_range, try to access y="+MC_string_converter::to_string(X[1])+"/"+MC_string_converter::to_string(dimension[1]));
        if(X[2]<0 || X[2]>=dimension[2])
            throw exception::MC_exception_grid_3d_out_of_bounds("Error in MC_grid_3d::assert_is_in_range, try to access z="+MC_string_converter::to_string(X[2])+"/"+MC_string_converter::to_string(dimension[2]));

    }

    template <typename VALUE>
            MC_grid_3d<VALUE>::MC_grid_3d()
            :dimension(MC_int_vector(0,0,0))
    {}

    template <typename VALUE>
            void MC_grid_3d<VALUE>::fill(const VALUE& y)
    {
        unsigned int N=grid.size();
        if(N>0)
        {
            VALUE* p_grid=&grid[0];
            for(unsigned int k=0;k<N;++k,++p_grid)
                *p_grid=y;
        }
    }




}

#endif