Array3D.h

Go to the documentation of this file.

/* =====================================================================================
 
                      The UQ Toolkit (UQTk) version 3.1.5
                          Copyright (2024) NTESS
                        https://www.sandia.gov/UQToolkit/
                        https://github.com/sandialabs/UQTk
 
     Copyright 2024 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
     Under the terms of Contract DE-NA0003525 with NTESS, the U.S. Government
     retains certain rights in this software.
 
     This file is part of The UQ Toolkit (UQTk)
 
     UQTk is open source software: you can redistribute it and/or modify
     it under the terms of BSD 3-Clause License
 
     UQTk 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
     BSD 3 Clause License for more details.
 
     You should have received a copy of the BSD 3 Clause License
     along with UQTk. If not, see https://choosealicense.com/licenses/bsd-3-clause/.
 
     Questions? Contact the UQTk Developers at https://github.com/sandialabs/UQTk/discussions
     Sandia National Laboratories, Livermore, CA, USA
===================================================================================== */
 
 
#ifndef ARRAY3D_H_SEEN
#define ARRAY3D_H_SEEN
 
#include <stddef.h>
#include <vector>
#include <iostream>
#include <fstream>
#include <iterator>
#include <algorithm>
 
using namespace std;
 
template <typename T>
class Array3D {
  public:
    Array3D(): xsize_(0), ysize_(0), zsize_(0) {};
 
    Array3D(const size_t& nx, const size_t& ny, const size_t& nz):
      xsize_(nx), ysize_(ny), zsize_(nz) {
      data_.resize(xsize_*ysize_*zsize_);
    }
 
    Array3D(const size_t& nx, const size_t& ny, const size_t& nz, const T& t):
      xsize_(nx), ysize_(ny), zsize_(nz) {
      data_.resize(xsize_*ysize_*zsize_ , t);
    }
 
    ~Array3D() {data_.clear();}
 
    void Clear() {
      xsize_ = 0;
      ysize_ = 0;
      zsize_ = 0;
      data_.clear();
    }
 
    size_t XSize() const {return xsize_;}
    size_t YSize() const {return ysize_;}
    size_t ZSize() const {return zsize_;}
 
    void Resize(const size_t& nx, const size_t& ny, const size_t& nz) {
      xsize_ = nx;
      ysize_ = ny;
      zsize_ = nz;
      data_.resize(xsize_*ysize_*zsize_);
    }
 
    void Resize(const size_t& nx, const size_t& ny, const size_t& nz, const T& t) {
      data_.clear();
      xsize_ = nx;
      ysize_ = ny;
      zsize_ = nz;
      data_.resize(xsize_*ysize_*zsize_ , t);
    }
 
    void SetValue(const T& t){
      for(size_t i=0; i < data_.size(); i++){
        data_[i] = t;
      }
    }
 
    T* GetArrayPointer() {
      return &(data_[0]);
    }
 
    const T* GetConstArrayPointer() const {
      return &(data_[0]);
    }
 
    T& operator()(size_t ix, size_t iy, size_t iz) {return data_[ix+xsize_*(iy+ysize_*iz)];}
 
    const T& operator()(size_t ix, size_t iy, size_t iz) const {return data_[ix+xsize_*(iy+ysize_*iz)];}
 
    void DumpBinary(FILE* f_out) const {
      fwrite(&xsize_,sizeof(xsize_),1,f_out);
      fwrite(&ysize_,sizeof(ysize_),1,f_out);
      fwrite(&zsize_,sizeof(zsize_),1,f_out);
      fwrite(this->GetConstArrayPointer(),sizeof(T),xsize_*ysize_*zsize_,f_out);
    }
    
    void DumpText(std::ofstream& f_out) const {
      vector<double>::const_iterator it1;
      vector<double>::const_iterator it2;
      it2=data_.begin();
      
      for (int iz=0;iz<zsize_;iz++) {
        for (int iy=0;iy<ysize_;iy++) {
          it1=it2;
          advance(it2,xsize_);
          std::copy(it1,it2,std::ostream_iterator<T>(f_out," "));
          f_out << endl;
        }
      }
      
    }
 
    void ReadText(FILE* f_in){
      fread(&xsize_,sizeof(xsize_),1,f_in);
      fread(&ysize_,sizeof(ysize_),1,f_in);
      fread(&zsize_,sizeof(zsize_),1,f_in);
      data_.resize(xsize_*ysize_*zsize_);
      fread(this->GetArrayPointer(),sizeof(T),xsize_*ysize_*zsize_,f_in);
    }
 
    void ReadBinary(std::ifstream& f_in){
      
      typedef std::istream_iterator<T> istream_iterator;
      std::copy(istream_iterator(f_in),istream_iterator(),data_.begin());
    }
       
 
  private:
 
    Array3D(const Array3D &obj) {};
 
    size_t xsize_;
    size_t ysize_;
    size_t zsize_;
 
    vector<T> data_;
};
 
#endif /* ARRAY3D_H_SEEN */