tensor.h

//
// tensor.h --- tensor class that contains an interface to MemoryGrp etc
//
// Copyright (C) 2008 Toru Shiozaki
//
// Author: Toru Shiozaki <shiozaki.toru@gmail.com>
// Maintainer: TS
//
// 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_ccr12_tensor_h
#define _chemistry_qc_ccr12_tensor_h
 
#include <string>
#include <vector>
#include <util/misc/compute.h>
#include <util/group/memory.h>
#include <util/group/memregion.h>
#include <util/group/message.h>
#include <util/group/thread.h>
#include <math/distarray4/distarray4.h>
 
// note disk-based algorithm does not support parallel execution so far.
#define DISK_BASED_SMITH
 
#ifdef DISK_BASED_SMITH
#include <fstream>
#endif
 
namespace sc {
 
class Tensor : virtual public RefCount {
  protected:
    const Ref<MemoryGrp>& mem_;
 
    std::string filename_;
 
    std::map<long,long> hash_table_;
 
    long filesize_;
 
#ifndef DISK_BASED_SMITH
    MemoryGrpRegion* file_;
#else
    std::fstream* file_;
#endif
    bool file_allocated_;
 
    std::vector<long> determine_filesizes();
 
  public:
    Tensor(std::string filename,const Ref<MemoryGrp>& mem);
    ~Tensor();
 
    std::string filename() const {return filename_;};
 
#ifndef DISK_BASED_SMITH
    MemoryGrpRegion* file() const {return file_;};
#else
    std::fstream* file() { return file_; };
#endif
 
    void set_filesize(long i);
    long get_filesize() const {return filesize_;};
 
    void createfile();
    void deletefile();
 
    void input_offset(long tag, long offset);
 
    void get_block(long tag, double* data);
    void add_block(long tag, double* data);
    void put_block(long tag, double* data);
    bool exists(long tag) const;
    bool is_this_local(long tag);
 
    void zero();
 
    void assign(double a);
 
    double norm() const;
 
    double ddot(Ref<Tensor>&) const;
 
    Ref<Tensor> copy() const;
 
    Ref<Tensor> clone() const;
 
    void daxpy(const Ref<Tensor>&, double);
 
    void scale(double a);
 
#ifndef DISK_BASED_SMITH 
    void sync() const { const_cast<MemoryGrpRegion*>(file_)->sync();};
#else
    void sync() const {}; // disk-based algorithm does not support parallel runs so far
#endif
 
    void print(const std::string& label, std::ostream& os = ExEnv::out0()) const;
};
 
double RMS(const Tensor& t);
 
}
 
#endif