DTGrid3Dex.hpp

Go to the documentation of this file.

 
#ifndef DTGRID3DEX_HPP_
#define DTGRID3DEX_HPP_
//
#include <stdlib.h>
#include <string.h>
#include <cstring>
#include <iostream>
#include <fstream>
#include <sstream>
#include <typeinfo>
//
#include "ArrayReg.hpp"
#include "ArrayPtr.hpp"
#include "ArrayPrs.hpp"
#include "DTGrid2D.hpp"
 
class DTGrid3Dex {
public:
    DTGrid3Dex(char *);
    ~DTGrid3Dex();
    
private:
 
    ArrayReg <bool> * Value_List_3D;
    ArrayPrs <int> * Zcoord_List;
    ArrayPtr <bool,int> * Ptr_List_3D;
 
    DTGrid2D <bool,int> * proj2D;
 
    int Length_of_Value_List_3D;
    int Length_of_Zcoord_List;
    int Length_of_Ptr_List_3D;
 
    int iform;
 
    int grid_type;
    
    float scale; 
    float spacing; 
 
    struct {
        int i;
        int j;
        int k;
    }dimensions;
    
    struct {
        float x;
        float y;
        float z;
    }origin;
    
    //
    void set_zcoord_list(int*,int);
    void set_projection2D(int*, int*, int*, int*, int*, int*, int, int, int, int, int, int);
    void set_uhbd_parameters(float, float, float, float, float, int, int, int);
    void Reset_pointers_3D(void);
 
    //
    void test_format_dtgrid(char *);
    void size_ds(unsigned int);
    void format_ascii(char *);
    void format_binary(char *);
 
public:
    struct {
        char * Title;
        int grdflag;
        int one;
        int idummy1;
        int idummy2;
        int idummy3;
        int idummy4;
        int idummy5;
        float scale;
        float spacing;
        float dummy1;
        float dummy2;
        float dummy3;
        float dummy4;
        float dummy5;
        float dummy6;
        float dummy7;
        struct dimensions
        {
            int i;
            int j;
            int k;
        }dim;
        struct origin
        {
            float x;
            float y;
            float z;
        }o;
    }uhbd;
 
    bool accessxyz(int, int, int);
    bool * getCell(bool *, int, int, int);
    bool * getCell2(bool *, int, int, int);
 
protected:
    void getCellz(bool *, int, int, int, typename ArrayPrs <int>::PairArray *);
    void getCellyz(bool *, int, int, int, typename ArrayPrs <int>::PairArray *);
 
};
 
DTGrid3Dex::~DTGrid3Dex(){
    delete proj2D;
    delete Zcoord_List;
}
 
 
DTGrid3Dex::DTGrid3Dex(char * file_name){
 
    Length_of_Ptr_List_3D = 0;
    Length_of_Value_List_3D = 0;
 
    test_format_dtgrid(file_name);
    if (iform == 0)
        format_binary(file_name);
    else if (iform == 1)
        format_ascii(file_name);
    else{
        std::cout << "Error: Unknown file format" << std::endl;
        exit(0);
    }
}
 
 
void DTGrid3Dex::set_zcoord_list(int* values, int length){
    Zcoord_List = new (std::nothrow) ArrayPrs <int>;
    Zcoord_List->Set_Pair_Array_Values(values,length);
    Length_of_Zcoord_List = length;
}
 
 
void DTGrid3Dex::set_projection2D(int* values1, int* values2, int* values3, \
        int* values4, int* values5, int* values6, int length1, int length2, \
        int length3, int length4, int length5, int length6){
 
    proj2D = new (std::nothrow) DTGrid2D <bool,int>;
    proj2D->set_value_list_2D(values1,length1);
    proj2D->set_ycoord_list(values2,length2);
    proj2D->set_ptr_list_2D(values3,length3);
    proj2D->set_projection1D(values4, values5, values6, length4, length5, length6);
}
 
 
void DTGrid3Dex::set_uhbd_parameters(float sc, float sp, float ox, float oy, float oz, int dimi, int dimj, int dimk){
    scale = sc;
    spacing = sp;
    
    origin.x = ox;
    origin.y = oy;
    origin.z = oz;
    
    dimensions.i = dimi;
    dimensions.j = dimk;
    dimensions.k = dimk;
}
 
 
bool DTGrid3Dex::accessxyz(int a, int b, int c){
 
    // Call the random access function in the DTGrid2D.
    typename ArrayPrs <int>::PairArray * coord3 = proj2D->accessxy(a,b);
 
    // Return the default value if recursive function call returns NULL.
    if (coord3 == NULL) return false;
 
    bool key3 = false; // a local logical operation variable.
 
    int checkpoint_31 = coord3->v2; // the index of the first connected component in a tubular grid in the zCoord array.
    int checkpoint_32 = (coord3+1)->v2; // the index of the last connected component in a tubular grid in the zCoord array.
    int countdown_3 = checkpoint_32 - checkpoint_31; // Determine how many connected components are there in the corresponding tubular grid (3D).
 
    // Return when no connected component found
    if (countdown_3 == 0) return false;
 
    typename ArrayPrs <int>::PairArray * coo3 = Zcoord_List->PArray+checkpoint_31; // a temporary pointer to store an zCoord array pair.
 
    // iterate over the connected components in DTGrid3Dex
    for (; countdown_3 >= 1; countdown_3--){
 
        // check whether index c is inside one of the connected components using the zCoord index array.
        key3 = c>=coo3->v1 ? (c<=coo3->v2 ? true : false) : false;
        if (key3 == true){
            return true;
        }
        else {
            ++coo3;
            continue;
        }
    }
    return false;
}
 
 
void DTGrid3Dex::getCellz(bool * Cell, int x, int y, int c, typename ArrayPrs <int>::PairArray * coord3){
 
    short skey3;
    int cinc = c+1;
 
    int checkpoint_31 = coord3->v2;
    int checkpoint_32 = (coord3+1)->v2;
    int countdown_3 = checkpoint_32 - checkpoint_31;
 
    typename ArrayPrs <int>::PairArray * coo3 = Zcoord_List->PArray+checkpoint_31;
 
    for (; countdown_3 >= 1; countdown_3--){
        skey3 = c>=coo3->v1 ? (cinc<=coo3->v2 ? 1 : (c<=coo3->v2 ? 2 : 0) ) : (cinc>=coo3->v1 ? (cinc<=coo3->v2 ? 3 : 0) : 0);
        //key3 = c>=coo3->v1 ? (c<=coo3->v2 ? true : false) : false;
        switch (skey3)
        {
        case 0:
            ++coo3;
            break;
        case 1:
            Cell[4*x+2*y] = true;
            Cell[4*x+2*y+1] = true;
            return;
        case 2:
            Cell[4*x+2*y] = true;
            return;
        case 3:
            Cell[4*x+2*y+1] = true;
            return;
        }
    }
    return;
}
 
 
void DTGrid3Dex::getCellyz(bool * Cell, int x, int b, int c, typename ArrayPrs <int>::PairArray * coord2){
 
    short skey2;
    int binc = b+1;
 
    int checkpoint_21 = coord2->v2;
    int checkpoint_22 = (coord2+1)->v2;
    int countdown_2 = checkpoint_22 - checkpoint_21;
 
    if (countdown_2 == 0){ return;}
 
    typename ArrayPrs <int>::PairArray ** ptt2 = proj2D->Ptr_List_2D->PtrArray+checkpoint_21;
    typename ArrayPrs <int>::PairArray * coo2 = proj2D->Ycoord_List->PArray+checkpoint_21;
 
    for (; countdown_2 >= 1; countdown_2--){
        skey2 = b>=coo2->v1 ? (binc<=coo2->v2 ? 1 : (b<=coo2->v2 ? 2 : 0) ) : (binc>=coo2->v1 ? (binc<=coo2->v2 ? 3 : 0) : 0);
 
        switch (skey2)
        {
        case 0:
            ++ptt2;
            ++coo2;
            break;
        case 1:
            getCellz(Cell, x,0,c, *(ptt2)+b-coo2->v1);
            //++b;
            getCellz(Cell, x,1,c, *(ptt2)+binc-coo2->v1);
            return;
        case 2:
            //printf("%d %d %d %d\n",b,b+1,coo2->v1,coo2->v2);
            getCellz(Cell, x,0,c, *(ptt2)+b-coo2->v1);
            return;
        case 3:
            getCellz(Cell, x,1,c, *(ptt2)+binc-coo2->v1);
            return;
        }
    }
    return;
}
 
 
bool * DTGrid3Dex::getCell(bool * Cell, int a, int b, int c){
 
    short skey1;
    int ainc = a+1;
    int countdown_1 = proj2D->proj1D->set_countdown_1;
 
    typename ArrayPrs <int>::PairArray ** ptt1 = proj2D->proj1D->Ptr_List_1D->PtrArray;
    typename ArrayPrs <int>::PairArray * coo1 = proj2D->proj1D->Xcoord_List->PArray;
 
    for (;countdown_1>0;countdown_1--){
        skey1 = a>=coo1->v1 ? (ainc<=coo1->v2 ? 1 : (a<=coo1->v2 ? 2 : 0) ) : (ainc>=coo1->v1 ? (ainc<=coo1->v2 ? 3 : 0) : 0);
        switch (skey1)
        {
        case 0:
            ++ptt1;
            ++coo1;
            break;
        case 1:
            getCellyz(Cell, 0,b,c, *(ptt1) + a - coo1->v1);
            getCellyz(Cell, 1,b,c, *(ptt1) + ainc - coo1->v1);
            return Cell;
        case 2:
            getCellyz(Cell, 0,b,c, *(ptt1) + a - coo1->v1);
            return Cell;
        case 3:
            getCellyz(Cell, 1,b,c, *(ptt1) + ainc - coo1->v1);
            return Cell;
        }
    }
    return Cell;
}
 
 
bool * DTGrid3Dex::getCell2(bool * Cell, int a, int b, int c){
 
    short skey1;
    int ainc = a+1;
 
    typename ArrayPrs <int>::PairArray ** ptt1 = proj2D->proj1D->Ptr_List_1D->PtrArray;
    typename ArrayPrs <int>::PairArray * coo1 = proj2D->proj1D->Xcoord_List->PArray;
 
    skey1 = a>=coo1->v1 ? (ainc<=coo1->v2 ? 1 : (a<=coo1->v2 ? 2 : 0) ) : (ainc>=coo1->v1 ? (ainc<=coo1->v2 ? 3 : 0) : 0);
    switch (skey1)
    {
    case 1:
        getCellyz(Cell, 0,b,c, *(ptt1) + a - coo1->v1);
        getCellyz(Cell, 1,b,c, *(ptt1) + ainc - coo1->v1);
        return Cell;
    case 2:
        getCellyz(Cell, 0,b,c, *(ptt1) + a - coo1->v1);
        return Cell;
    case 3:
        getCellyz(Cell, 1,b,c, *(ptt1) + ainc - coo1->v1);
        return Cell;
    default:
        return Cell;
    }
}
 
 
void DTGrid3Dex::test_format_dtgrid(char * Input)
{
    std::ifstream file_bt;
    file_bt.open(Input, std::ifstream::in | std::ifstream::binary);
 
    int flag;
    file_bt.read((char *) &flag, sizeof(int));
 
    //Read the first 120 characters
    char * buffer = new char [120];
    file_bt.read(buffer, 120);
 
    char * binary_test;
    binary_test = (char*) memchr (buffer, '\n', 120);
 
    if (flag == 160){
        //Binary file
        std::cout << "Test format dtgrid: No return statement, binary zeros found" << std::endl;
        std::cout << "The file was detected to be of type binary" << std::endl;
        iform = 0;
    }
    else{
        if (binary_test == NULL) { // NO return statement
            binary_test = (char*) memchr (buffer, '\0', 120);
            if (binary_test == NULL) {
                //ASCII file
                std::cout << "Test format dtgrid: No return statement, no binary zeros" << std::endl;
                std::cout << "The file was detected to be of type ASCII" << std::endl;
                iform = 1;
            }
            else{
                //Binary file
                std::cout << "Test format dtgrid: No return statement, binary zeros found" << std::endl;
                std::cout << "The file was detected to be of type binary" << std::endl;
                iform = 0;
            }
        }
        else{
            //ASCII file
            std::cout << "Test format dtgrid: Return statement found" << std::endl;
            std::cout << "The file was detected to be of type ASCII" << std::endl;
            iform = 1;
        }
    }
    file_bt.close();
    delete[] buffer;
}
 
 
void DTGrid3Dex::format_binary(char * file_binary)
{
    std::ifstream dtgrid_file;
    dtgrid_file.open(file_binary, std::ifstream::in | std::ifstream::binary);
 
    float sc, sp, ox, oy, oz, fval;
    int dimi, dimj, dimk, ival, flag_binary, flag_grid_type;
 
    //uhbd header parameters
    dtgrid_file.read((char *) &flag_binary, sizeof(int));
    uhbd.Title = new char [72];
    dtgrid_file.read(uhbd.Title, 72);
    dtgrid_file.read((char *) &uhbd.scale, sizeof(float));
    dtgrid_file.read((char *) &uhbd.dummy1, sizeof(float));
    dtgrid_file.read((char *) &uhbd.grdflag, sizeof(int));
    dtgrid_file.read((char *) &uhbd.idummy1, sizeof(int));
    dtgrid_file.read((char *) &uhbd.idummy2, sizeof(int));
    dtgrid_file.read((char *) &uhbd.one, sizeof(int));
    dtgrid_file.read((char *) &uhbd.idummy3, sizeof(int));
    dtgrid_file.read((char *) &uhbd.dim.i, sizeof(int));
    dtgrid_file.read((char *) &uhbd.dim.j, sizeof(int));
    dtgrid_file.read((char *) &uhbd.dim.k, sizeof(int));
    dtgrid_file.read((char *) &uhbd.spacing, sizeof(float));
    dtgrid_file.read((char *) &uhbd.o.x, sizeof(float));
    dtgrid_file.read((char *) &uhbd.o.y, sizeof(float));
    dtgrid_file.read((char *) &uhbd.o.z, sizeof(float));
    dtgrid_file.read((char *) &uhbd.dummy2, sizeof(float));
    dtgrid_file.read((char *) &uhbd.dummy3, sizeof(float));
    dtgrid_file.read((char *) &uhbd.dummy4, sizeof(float));
    dtgrid_file.read((char *) &uhbd.dummy5, sizeof(float));
    dtgrid_file.read((char *) &uhbd.dummy6, sizeof(float));
    dtgrid_file.read((char *) &uhbd.dummy7, sizeof(float));
    dtgrid_file.read((char *) &uhbd.idummy4, sizeof(int));
    dtgrid_file.read((char *) &uhbd.idummy5, sizeof(int));
 
    //DT-Grid header parameters
    int len_Value, len_xcoord, len_ycoord, len_zcoord;
    int len_acc, len_acc2, len_acc3, len_projection, len_projection2;
 
    dtgrid_file.read((char *) &flag_grid_type, sizeof(int));
    dtgrid_file.read((char *) &len_Value, sizeof(int));
    dtgrid_file.read((char *) &len_xcoord, sizeof(int));
    dtgrid_file.read((char *) &len_ycoord, sizeof(int));
    dtgrid_file.read((char *) &len_zcoord, sizeof(int));
    dtgrid_file.read((char *) &len_acc, sizeof(int));
    dtgrid_file.read((char *) &len_acc2, sizeof(int));
    dtgrid_file.read((char *) &len_acc3, sizeof(int));
    dtgrid_file.read((char *) &len_projection, sizeof(int));
    dtgrid_file.read((char *) &len_projection2, sizeof(int));
 
    grid_type = flag_grid_type;
    if (grid_type == 0)
        std::cout << "Type of grid: Excluded volume" << std::endl;
    else if (grid_type == 1)
        std::cout << "Type of grid: Potential/Energy" << std::endl;
    else
        std::cout << "Type of grid: Unknown/Not-Set" << std::endl;
 
    std::cout << "DT-Grid Header information: " << std::endl;
    std::cout << "Length of Value array:\t" << len_Value << std::endl;
    std::cout << "Length of xCoord array:\t" << len_xcoord<< std::endl;
    std::cout << "Length of yCoord array:\t" << len_ycoord << std::endl;
    std::cout << "Length of zCoord array:\t" << len_zcoord << std::endl;
    std::cout << "Length of acc1D array:\t" << len_acc << std::endl;
    std::cout << "Length of acc2D array:\t" << len_acc2 << std::endl;
    std::cout << "Length of acc3D array:\t" << len_acc3 << std::endl;
    std::cout << "Length of proj1D array:\t" << len_projection << std::endl;
    std::cout << "Length of proj2D array:\t" << len_projection2 << std::endl << std::endl;
 
    int dtgrid_size;
    dtgrid_size = sizeof(int) * (len_xcoord + len_ycoord + len_zcoord + \
            len_acc + len_acc2 + len_acc3) + sizeof(int *) * (len_projection + len_projection2);
    size_ds(dtgrid_size);
 
    //dtgrid main body
    int * zcoord;
    zcoord = new int [len_zcoord];
    for (int i=0;i<len_zcoord;i++){
        dtgrid_file.read((char *) &ival, sizeof(int));
        zcoord[i] = (int) ival;
    }
 
    int * acc;
    acc = new int [len_acc];
    for (int i=0;i<len_acc;i++){
        dtgrid_file.read((char *) &ival, sizeof(int));
        acc[i] = (int) ival;
    }
 
    int * projection;
    projection = new int [len_projection];
    for (int i=0;i<len_projection;i++){
        dtgrid_file.read((char *) &ival, sizeof(int));
        projection[i] = (int) ival;
    }
 
    int * ycoord;
    ycoord = new int [len_ycoord];
    for (int i=0;i<len_ycoord;i++){
        dtgrid_file.read((char *) &ival, sizeof(int));
        ycoord[i] = (int) ival;
    }
 
    int * acc2;
    acc2 = new int [len_acc2];
    for (int i=0;i<len_acc2;i++){
        dtgrid_file.read((char *) &ival, sizeof(int));
        acc2[i] = (int) ival;
    }
 
    int * projection2;
    projection2 = new int [len_projection2];
    for (int i=0;i<len_projection2;i++){
        dtgrid_file.read((char *) &ival, sizeof(int));
        projection2[i] = (int) ival;
    }
 
    int * xcoord;
    xcoord = new int [len_xcoord];
    for (int i=0;i<len_xcoord;i++){
        dtgrid_file.read((char *) &ival, sizeof(int));
        xcoord[i] = (int) ival;
    }
 
    int * acc3;
    acc3 = new int [len_acc3];
    for (int i=0;i<len_acc3;i++){
        dtgrid_file.read((char *) &ival, sizeof(int));
        acc3[i] = (int) ival;
    }
 
    // Initialization of the grid object
    set_uhbd_parameters(uhbd.scale, uhbd.spacing, uhbd.o.x, uhbd.o.y, \
            uhbd.o.z, uhbd.dim.i, uhbd.dim.j, uhbd.dim.k);
    set_zcoord_list(zcoord,len_zcoord);
    set_projection2D(projection,ycoord,acc2,projection2,xcoord,acc3,len_projection, \
            len_ycoord,len_acc2,len_projection2,len_xcoord,len_acc3);
 
    delete[] zcoord;
    delete[] acc;
    delete[] projection;
    delete[] ycoord;
    delete[] acc2;
    delete[] projection2;
    delete[] xcoord;
    delete[] acc3;
 
    dtgrid_file.close();
}
 
 
void DTGrid3Dex::format_ascii(char * file_ascii)
{
    std::ifstream dtgrid_file;
    dtgrid_file.open(file_ascii, std::ifstream::in);
 
    std::string title_str, line;
    std::string scale_str, dum1_str, grdflag_str, idum1_str, idum2_str, one_str, idum3_str;
    std::string i_str, j_str, k_str;
    std::string spacing_str, ox_str, oy_str, oz_str;
    std::string dum2_str, dum3_str, dum4_str, dum5_str;
    std::string dum6_str, dum7_str, idum4_str, idum5_str;
 
    bool fval;
    int ival;
    int flag_grid_type;
    int len_Value, len_xcoord, len_ycoord, len_zcoord;
    int len_acc, len_acc2, len_acc3, len_projection, len_projection2;
 
    //DTGrid (UHBD) Title
    getline(dtgrid_file,line);
    title_str = line.substr(0,72);
 
    //uhbd header parameters
    getline(dtgrid_file,line);
    scale_str = line.substr(0,12);
    dum1_str = line.substr(12,12);
    grdflag_str = line.substr(24,7);
    idum1_str = line.substr(31,7);
    idum2_str = line.substr(38,7);
    one_str = line.substr(45,7);
    idum3_str = line.substr(52,7);
    getline(dtgrid_file,line);
    i_str = line.substr(0,7);
    j_str = line.substr(7,7);
    k_str = line.substr(14,7);
    spacing_str = line.substr(21,12);
    ox_str = line.substr(33,12);
    oy_str = line.substr(45,12);
    oz_str = line.substr(57,12);
    getline(dtgrid_file,line);
    dum2_str = line.substr(0,12);
    dum3_str = line.substr(12,12);
    dum4_str = line.substr(24,12);
    dum5_str = line.substr(36,12);
    getline(dtgrid_file,line);
    dum6_str = line.substr(0,12);
    dum7_str = line.substr(12,12);
    idum4_str = line.substr(24,7);
    idum5_str = line.substr(31,7);
 
    //
    uhbd.Title = new char [72];
    std::strncpy (uhbd.Title, title_str.c_str(), 72);
 
    std::stringstream (scale_str) >> uhbd.scale;
    std::stringstream (dum1_str) >> uhbd.dummy1;
    std::stringstream (grdflag_str) >> uhbd.grdflag;
    std::stringstream (idum1_str) >> uhbd.idummy1;
    std::stringstream (idum2_str) >> uhbd.idummy2;
    std::stringstream (one_str) >> uhbd.one;
    std::stringstream (idum3_str) >> uhbd.idummy3;
    std::stringstream (i_str) >> uhbd.dim.i;
    std::stringstream (j_str) >> uhbd.dim.j;
    std::stringstream (k_str) >> uhbd.dim.k;
    std::stringstream (spacing_str) >> uhbd.spacing;
    std::stringstream (ox_str) >> uhbd.o.x;
    std::stringstream (oy_str) >> uhbd.o.y;
    std::stringstream (oz_str) >> uhbd.o.z;
    std::stringstream (dum2_str) >> uhbd.dummy2;
    std::stringstream (dum3_str) >> uhbd.dummy3;
    std::stringstream (dum4_str) >> uhbd.dummy4;
    std::stringstream (dum5_str) >> uhbd.dummy5;
    std::stringstream (dum6_str) >> uhbd.dummy6;
    std::stringstream (dum7_str) >> uhbd.dummy7;
    std::stringstream (idum4_str) >> uhbd.idummy4;
    std::stringstream (idum5_str) >> uhbd.idummy5;
 
 
    //dtgrid header parameters
    dtgrid_file >> flag_grid_type;
    dtgrid_file >> len_Value;
    dtgrid_file >> len_xcoord;
    dtgrid_file >> len_ycoord;
    dtgrid_file >> len_zcoord;
    dtgrid_file >> len_acc;
    dtgrid_file >> len_acc2;
    dtgrid_file >> len_acc3;
    dtgrid_file >> len_projection;
    dtgrid_file >> len_projection2;
 
    grid_type = flag_grid_type;
    if (grid_type == 0)
        std::cout << "Type of grid: Excluded volume" << std::endl;
    else if (grid_type == 1)
        std::cout << "Type of grid: Potential/Energy" << std::endl;
    else
        std::cout << "Type of grid: Unknown/Not-Set" << std::endl;
 
    std::cout << "DT-Grid Header information: " << std::endl;
    std::cout << "Length of Value array:\t" << len_Value << std::endl;
    std::cout << "Length of xCoord array:\t" << len_xcoord<< std::endl;
    std::cout << "Length of yCoord array:\t" << len_ycoord << std::endl;
    std::cout << "Length of zCoord array:\t" << len_zcoord << std::endl;
    std::cout << "Length of acc1D array:\t" << len_acc << std::endl;
    std::cout << "Length of acc2D array:\t" << len_acc2 << std::endl;
    std::cout << "Length of acc3D array:\t" << len_acc3 << std::endl;
    std::cout << "Length of proj1D array:\t" << len_projection << std::endl;
    std::cout << "Length of proj2D array:\t" << len_projection2 << std::endl << std::endl;
 
    unsigned int dtgrid_size;
    dtgrid_size = sizeof(int) * (len_xcoord + len_ycoord + len_zcoord + \
            len_acc + len_acc2 + len_acc3) + sizeof(int *) * (len_projection + len_projection2);
    size_ds(dtgrid_size);
 
    //dtgrid main body
    int * zcoord;
    zcoord = new int [len_zcoord];
    for (int i=0;i<len_zcoord;i++){
        dtgrid_file >> ival;
        zcoord[i] = ival;
    }
 
    int * acc;
    acc = new int [len_acc];
    for (int i=0;i<len_acc;i++){
        dtgrid_file >> ival;
        acc[i] = ival;
    }
 
    int * projection;
    projection = new int [len_projection];
    for (int i=0;i<len_projection;i++){
        dtgrid_file >> ival;
        projection[i] = ival;
    }
 
    int * ycoord;
    ycoord = new int [len_ycoord];
    for (int i=0;i<len_ycoord;i++){
        dtgrid_file >> ival;
        ycoord[i] = ival;
    }
 
    int * acc2;
    acc2 = new int [len_acc2];
    for (int i=0;i<len_acc2;i++){
        dtgrid_file >> ival;
        acc2[i] = ival;
    }
 
    int * projection2;
    projection2 = new int [len_projection2];
    for (int i=0;i<len_projection2;i++){
        dtgrid_file >> ival;
        projection2[i] = ival;
    }
 
    int * xcoord;
    xcoord = new int [len_xcoord];
    for (int i=0;i<len_xcoord;i++){
        dtgrid_file >> ival;
        xcoord[i] = ival;
    }
 
    int * acc3;
    acc3 = new int [len_acc3];
    for (int i=0;i<len_acc3;i++){
        dtgrid_file >> ival;
        acc3[i] = ival;
    }
 
    // Initialization of the grid object
    set_uhbd_parameters(uhbd.scale, uhbd.spacing, uhbd.o.x, uhbd.o.y, \
                    uhbd.o.z, uhbd.dim.i, uhbd.dim.j, uhbd.dim.k);
    set_zcoord_list(zcoord,len_zcoord);
    set_projection2D(projection,ycoord,acc2,projection2,xcoord,acc3,len_projection, \
            len_ycoord,len_acc2,len_projection2,len_xcoord,len_acc3);
    delete[] zcoord;
    delete[] acc;
    delete[] projection;
    delete[] ycoord;
    delete[] acc2;
    delete[] projection2;
    delete[] xcoord;
    delete[] acc3;
 
    dtgrid_file.close();
}
 
 
void DTGrid3Dex::size_ds(unsigned int val)
{
    float dtgrid_size;
    int kb, mb, gb;
 
    kb = 1024;
    mb = 1024 * 1024;
    gb = 1024 * 1024 * 1024;
 
    if ((val / gb) > 1) {
        dtgrid_size = (float) val / (float) gb;
        std::cout << "Size of DT-Grid data structure is " << dtgrid_size << " GB" << std::endl;
    }
    else {
        if ((val / mb) > 1) {
            dtgrid_size = (float) val / (float) mb;
            std::cout << "Size of DT-Grid data structure is " << dtgrid_size << " MB" << std::endl;
        }
        else {
            dtgrid_size = (float) val / (float) kb;
            std::cout << "Size of DT-Grid data structure is " << dtgrid_size << " KB" << std::endl;
        }
    }
}
 
#endif /* DTGRID3DEX_HPP_ */