distarray4.h

//
// distarray4.h
//
// Copyright (C) 2002 Edward Valeev
//
// Author: Edward Valeev <evaleev@vt.edu>
// Maintainer: EV
//
// This file is part of the SC Toolkit.
//
// The SC Toolkit is free software; you can redistribute it and/or modify
// it under the terms of the GNU Library General Public License as published by
// the Free Software Foundation; either version 2, or (at your option)
// any later version.
//
// The SC Toolkit 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 Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public License
// along with the SC Toolkit; see the file COPYING.LIB.  If not, write to
// the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
//
// The U.S. Government is granted a limited license as per AL 91-7.
//
 
#ifndef _chemistry_qc_mbptr12_distarray4_h
#define _chemistry_qc_mbptr12_distarray4_h
 
#include <vector>
#include <util/ref/ref.h>
#include <util/state/state.h>
#include <util/state/statein.h>
#include <util/state/stateout.h>
#include <util/group/memory.h>
#include <util/group/message.h>
 
namespace sc {
 
  enum DistArray4Storage {DistArray4Storage_XY, DistArray4Storage_YX};
 
  struct DistArray4Dimensions {
    public:
      static const DistArray4Dimensions& default_dim() { return default_dim_; }
      DistArray4Dimensions(int num_te_types, int n1, int n2, int n3, int n4,
                           DistArray4Storage storage = DistArray4Storage_XY) :
        num_te_types_(num_te_types), n1_(n1), n2_(n2), n3_(n3), n4_(n4),
        storage_(storage)
        {
        }
      int num_te_types() const { return num_te_types_; }
      int n1() const { return n1_; }
      int n2() const { return n2_; }
      int n3() const { return n3_; }
      int n4() const { return n4_; }
      DistArray4Storage storage() const { return storage_; }
    private:
      static DistArray4Dimensions default_dim_;
      int num_te_types_;
      int n1_;
      int n2_;
      int n3_;
      int n4_;
      DistArray4Storage storage_;
  };
  bool operator==(const DistArray4Dimensions& A,
                  const DistArray4Dimensions& B);
 
 
class DistArray4: virtual public SavableState {
  public:
    // mem will be used to fetch data
    DistArray4(int num_te_types, int ni, int nj, int nx, int ny,
               DistArray4Storage storage = DistArray4Storage_XY);
    DistArray4(StateIn&);
    virtual ~DistArray4();
    void save_data_state(StateOut&);
 
    virtual Ref<DistArray4> clone(const DistArray4Dimensions& dim = DistArray4Dimensions::default_dim()) =0;
 
    typedef unsigned int tbint_type;
    static const unsigned int max_num_te_types = 14;
 
    int num_te_types() const { return num_te_types_; };
    int ni() const { return ni_; }
    int nj() const { return nj_; }
    int nx() const { return nx_; }
    int ny() const { return ny_; }
    const DistArray4Storage& storage() const { return storage_; }
    size_t blocksize() const { return blocksize_; };
    // same as blocksize(), but in bytes
    size_t blksize() const { return blksize_; }
 
    virtual void activate() { active_ = true; }
    virtual void deactivate() { active_ = false; }
    virtual bool data_persistent() const =0;
    virtual const double * retrieve_pair_block(int i, int j, tbint_type oper_type,
                                               double* buf = 0) const =0;
    virtual void retrieve_pair_subblock(int i, int j, tbint_type oper_type,
                                        int xstart, int xfence, int ystart, int yfence,
                                        double* buf) const =0;
    virtual void release_pair_block(int i, int j, tbint_type oper_type) const =0;
    virtual void store_pair_block(int i, int j, tbint_type oper_type, const double* ints) =0;
    virtual void store_pair_subblock(int i, int j, tbint_type oper_type,
                                     int xstart, int xfence, int ystart, int yfence,
                                     const double* ints) =0;
 
    int ij_index(int i, int j) const { return i*nj_ + j; };
 
    virtual bool is_avail(int i, int j) const =0;
    virtual bool is_local(int i, int j) const =0;
    virtual bool has_access(int proc) const =0;
    int tasks_with_access(std::vector<int>& twa_map) const;
 
    const Ref<MessageGrp>& msg() const { return msg_; }
 
    // return active_
    bool active() const { return active_; }
 
  private:
    static const int classdebug_ = 0;
 
    int num_te_types_;  // Number of types of integrals in a block
    Ref<MessageGrp> msg_;
    int ni_, nj_;
    int nx_, ny_;
    DistArray4Storage storage_;
    size_t nxy_;        // nx_ * ny_  - the number of integrals of one type in a block
    size_t blksize_;    // the same in bytes
    size_t blocksize_;  // hence the size of the block of num_te_types of integrals is blksize_ * num_te_types
 
    bool active_;
 
   protected:
    // return nxy_
    size_t nxy() const { return nxy_; }
    int ntasks() const { return msg_->n(); }
    int me() const { return msg_->me(); }
    int classdebug() const { return classdebug_; }
 
};
 
Ref<DistArray4> make_distarray4(int num_te_types, int ni, int nj, int nx, int ny,
                                DistArray4Storage storage = DistArray4Storage_XY);
 
Ref<DistArray4>
extract(const Ref<DistArray4>& A,
        unsigned int te_type,
        double scale = 1.0);
 
Ref<DistArray4> permute23(const Ref<DistArray4>& src);
 
Ref<DistArray4> permute34(const Ref<DistArray4>& src);
 
Ref<DistArray4> permute12(const Ref<DistArray4>& src);
 
 
void
axpy(const Ref<DistArray4>& X,
     double a,
     const Ref<DistArray4>& Y,
     double scale = 1.0);
 
void antisymmetrize(const Ref<DistArray4>& A);
 
void symmetrize(const Ref<DistArray4>& A);
 
void contract34(Ref<DistArray4>& braket,
                double scale,
                const Ref<DistArray4>& bra,
                unsigned int intsetidx_bra,
                const Ref<DistArray4>& ket,
                unsigned int intsetidx_ket,
                int debug = 0);
 
class RefSCMatrix;
 
void contract34_DA4_RefMat(Ref<DistArray4>& braket,
                                              double scale,
                                              const Ref<DistArray4>& bra,
                                              unsigned int intsetidx_bra,
                                              const RefSCMatrix& ket,
                                              const int MatBra1Dim, const int MatBra2Dim);
 
 
 
 
void contract_DA4_RefMat_k2b2_34(Ref<DistArray4>& braket,
                       double scale,
                       const Ref<DistArray4>& bra,
                       unsigned int intsetidx_bra,
                       const RefSCMatrix& ket,
                       const int MatBra1Dim, const int MatBra2Dim);
 
 
 
void contract_DA4_RefMat_k1b2_34(Ref<DistArray4>& braket,
                       double scale,
                       const Ref<DistArray4>& bra,
                       unsigned int intsetidx_bra,
                       const RefSCMatrix& ket,
                       const int MatBra1Dim, const int MatBra2Dim);
 
 
void contract3(const Ref<DistArray4>& ijxy, const RefSCMatrix& T, Ref<DistArray4>& ijzy);
 
void contract4(const Ref<DistArray4>& ijxy, const RefSCMatrix& T, Ref<DistArray4>& ijxz);
 
 
 
RefSCMatrix &
operator<<(RefSCMatrix& dst,
                        const Ref<DistArray4>& src);
 
RefSCMatrix &
copy_to_RefSCMat(RefSCMatrix& dst,
                        const Ref<DistArray4>& src, const int tensor_type);
 
RefSCMatrix
copy_to_RefSCMat(const Ref<DistArray4>& src, int tensor_index);
 
 
 
 
 
 
 
namespace detail {
 
  void store_memorygrp(Ref<DistArray4>& acc, Ref<MemoryGrp>& mem, int i_offset,
                       int ni, const size_t blksize_memgrp = 0);
 
  void restore_memorygrp(Ref<DistArray4>& acc, Ref<MemoryGrp>& mem, int i_offset,
                         int ni, DistArray4Storage storage, const size_t blksize_memgrp = 0);
 
}
 
}
 
#endif
 
// Local Variables:
// mode: c++
// c-file-style: "CLJ"
// End: