tensor_impl.h

Go to the documentation of this file.

/*
 *  This file is a part of TiledArray.
 *  Copyright (C) 2013  Virginia Tech
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program 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 program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef TILEDARRAY_TENSOR_IMPL_H__INCLUDED
#define TILEDARRAY_TENSOR_IMPL_H__INCLUDED
 
#include "TiledArray/external/madness.h"
#include "error.h"
#include "policies/dense_policy.h"
#include "policies/sparse_policy.h"
 
namespace TiledArray {
namespace detail {
 
 
template <typename Policy>
class TensorImpl : private NO_DEFAULTS {
 public:
  typedef TensorImpl<Policy> TensorImpl_;
  typedef Policy policy_type;                        
  typedef typename Policy::trange_type trange_type;  
  typedef typename Policy::range_type range_type;  
  typedef typename Policy::index1_type index1_type;    
  typedef typename Policy::ordinal_type ordinal_type;  
  typedef typename Policy::shape_type shape_type;      
  typedef typename Policy::pmap_interface
      pmap_interface;  
 
 private:
  World& world_;                          
  const trange_type trange_;              
  const shape_type shape_;                
  std::shared_ptr<pmap_interface> pmap_;  
 
 public:
 
  TensorImpl(World& world, const trange_type& trange, const shape_type& shape,
             const std::shared_ptr<pmap_interface>& pmap)
      : world_(world), trange_(trange), shape_(shape), pmap_(pmap) {
    // Validate input data.
    TA_ASSERT(pmap_);
    TA_ASSERT(pmap_->size() == trange_.tiles_range().volume());
    TA_ASSERT(pmap_->rank() ==
              typename pmap_interface::size_type(world_.rank()));
    TA_ASSERT(pmap_->procs() ==
              typename pmap_interface::size_type(world_.size()));
    TA_ASSERT(shape_.validate(trange_.tiles_range()));
    // ensure that shapes are identical on every rank
    TA_ASSERT(is_replicated(world, shape));
  }
 
  virtual ~TensorImpl() {}
 
 
  const std::shared_ptr<pmap_interface>& pmap() const { return pmap_; }
 
 
  const range_type& tiles_range() const { return trange_.tiles_range(); }
 
 
  ordinal_type size() const { return trange_.tiles_range().volume(); }
 
 
  ordinal_type local_size() const {
    return static_cast<ordinal_type>(pmap_->local_size());
  }
 
 
  template <typename Index>
  ProcessID owner(const Index& i) const {
    TA_ASSERT(trange_.tiles_range().includes(i));
    return pmap_->owner(trange_.tiles_range().ordinal(i));
  }
 
 
  template <typename Index>
  bool is_local(const Index& i) const {
    TA_ASSERT(trange_.tiles_range().includes(i));
    return pmap_->is_local(trange_.tiles_range().ordinal(i));
  }
 
 
  template <typename Index>
  bool is_zero(const Index& i) const {
    TA_ASSERT(trange_.tiles_range().includes(i));
    return shape_.is_zero(trange_.tiles_range().ordinal(i));
  }
 
 
  bool is_dense() const { return shape_.is_dense(); }
 
 
  const shape_type& shape() const { return shape_; }
 
 
  const trange_type& trange() const { return trange_; }
 
  [[deprecated]] World& get_world() const { return world_; }
 
 
  World& world() const { return world_; }
 
};  // class TensorImpl
 
#ifndef TILEDARRAY_HEADER_ONLY
 
extern template class TensorImpl<DensePolicy>;
extern template class TensorImpl<SparsePolicy>;
 
#endif  // TILEDARRAY_HEADER_ONLY
 
}  // namespace detail
}  // namespace TiledArray
 
#endif  // TILEDARRAY_TENSOR_IMPL_H__INCLUDED