Map.cpp

// =================================================================================== //
// INCLUDES                                                                            //
// =================================================================================== //
#include "tree_constants.hpp"
#include "Map.hpp"
#include <cmath>
 
namespace bitpit {
 
// =================================================================================== //
// NAME SPACES                                                                         //
// =================================================================================== //
using namespace std;
 
// =================================================================================== //
// CLASS IMPLEMENTATION                                                                    //
// =================================================================================== //
 
// =================================================================================== //
// CONSTRUCTORS AND OPERATORS
// =================================================================================== //
 
Map::Map(){
    initialize();
};
 
Map::Map(uint8_t dim){
    initialize(dim);
};
 
// =================================================================================== //
// METHODS
// =================================================================================== //
 
void Map::initialize(){
    initialize(0);
}
 
void Map::initialize(uint8_t dim){
    m_dim = dim;
 
    m_origin[0] = 0.;
    m_origin[1] = 0.;
    m_origin[2] = 0.;
 
    m_L = 1.0;
 
    if (m_dim > 0) {
        const TreeConstants &treeConstants = TreeConstants::instance(m_dim);
 
        m_nnodes        = treeConstants.nNodes;
        m_nnodesPerFace = treeConstants.nNodesPerFace;
 
        m_maxLength = treeConstants.lengths[0];
        m_maxArea   = treeConstants.areas[0];
        m_maxVolume = treeConstants.volumes[0];
 
        m_maxLength_1 = 1. / double(m_maxLength);
        m_maxArea_1   = 1. / double(m_maxArea);
        m_maxVolume_1 = 1. / double(m_maxVolume);
    } else {
        m_nnodes        = 0;
        m_nnodesPerFace = 0;
 
        m_maxLength = 0;
        m_maxArea   = 0;
        m_maxVolume = 0;
 
        m_maxLength_1 = std::numeric_limits<double>::infinity();
        m_maxArea_1   = std::numeric_limits<double>::infinity();
        m_maxVolume_1 = std::numeric_limits<double>::infinity();
    }
 
};
 
darray3 Map::mapCoordinates(u32array3 const & X) const {
    darray3 coords;
    for (int i=0; i<3; ++i){
        coords[i] = m_maxLength_1 * double(X[i]);
    }
    return coords;
};
 
double Map::mapX(uint32_t X) const {
    return m_maxLength_1 * double(X);
};
 
double Map::mapY(uint32_t Y) const {
    return m_maxLength_1 * double(Y);
};
 
double Map::mapZ(uint32_t Z) const {
    return m_maxLength_1 * double(Z);
};
 
u32array3 Map::mapCoordinates(darray3 const & X) const {
    u32array3 coords = {{0, 0, 0}};
    for (int i=0; i<3; ++i){
        coords[i] = (uint32_t)(double(m_maxLength) * X[i]);
    }
    return coords;
};
 
uint32_t Map::mapX(double X) const {
    return (uint32_t)(double(m_maxLength) * X);
};
 
uint32_t Map::mapY(double Y) const {
    return (uint32_t)(double(m_maxLength) * Y);
};
 
uint32_t Map::mapZ(double Z) const {
    return (uint32_t)(double(m_maxLength) * Z);
};
 
double Map::mapSize(uint32_t size) const {
    return m_maxLength_1 *double(size);
};
 
double Map::mapArea(uint64_t area) const {
    return m_maxArea_1*double(area);
};
 
double Map::mapVolume(uint64_t volume) const {
    return m_maxVolume_1*double(volume);
};
 
void Map::mapCenter(double* & center, darray3 & mapcenter) const {
    for (int i=0; i<3; i++){
        mapcenter[i] = m_maxLength_1 * center[i];
    }
};
 
void Map::mapCenter(darray3 & center, darray3 & mapcenter) const {
    for (int i=0; i<3; i++){
        mapcenter[i] = m_maxLength_1 * center[i];
    }
};
 
void Map::mapNodes(uint32_t (*nodes)[3], darr3vector & mapnodes) const {
    mapnodes.resize(m_nnodes);
    for (int i=0; i<m_nnodes; i++){
        for (int j=0; j<3; j++){
            mapnodes[i][j] = m_maxLength_1 * double(nodes[i][j]);
        }
    }
};
 
void Map::mapNodes(u32arr3vector nodes, darr3vector & mapnodes) const {
    mapnodes.resize(m_nnodes);
    for (int i=0; i<m_nnodes; i++){
        for (int j=0; j<3; j++){
            mapnodes[i][j] = m_maxLength_1 * double(nodes[i][j]);
        }
    }
};
 
void Map::mapNode(u32array3 & node, darray3 & mapnode) const {
    for (int j=0; j<3; j++){
        mapnode[j] = m_maxLength_1 * double(node[j]);
    }
};
 
void Map::mapNodesIntersection(uint32_t (*nodes)[3], darr3vector & mapnodes) const {
    mapnodes.resize(m_nnodesPerFace);
    for (int i=0; i<m_nnodesPerFace; i++){
        for (int j=0; j<3; j++){
            mapnodes[i][j] = m_maxLength_1 * double(nodes[i][j]);
        }
    }
};
 
void Map::mapNodesIntersection(u32arr3vector nodes, darr3vector & mapnodes) const {
    mapnodes.resize(m_nnodesPerFace);
    for (int i=0; i<m_nnodesPerFace; i++){
        for (int j=0; j<3; j++){
            mapnodes[i][j] = m_maxLength_1 * double(nodes[i][j]);
        }
    }
};
 
void Map::mapNormals(i8array3 normal, darray3 & mapnormal) const {
    mapnormal[0] = double(normal[0]);
    mapnormal[1] = double(normal[1]);
    mapnormal[2] = double(normal[2]);
};
 
}