cntr_distributed_timestep_array_impl.hpp

Go to the documentation of this file.

#ifndef CNTR_DISTRIBUTED_TIMESTEP_ARRAY_IMPL_H
#define CNTR_DISTRIBUTED_TIMESTEP_ARRAY_IMPL_H

#include "cntr_herm_matrix_timestep_view_decl.hpp"
#include "cntr_distributed_array_decl.hpp"
#include "cntr_distributed_timestep_array_decl.hpp"

namespace cntr {

/* #######################################################################################
#
#   CONSTRUCTION/DESTRUCTION
#
########################################################################################*/
template <typename T> distributed_timestep_array<T>::distributed_timestep_array(){
    n_=data_.n();
    tid_=data_.tid();
    ntasks_=data_.ntasks();
    G_=std::vector<cntr::herm_matrix_timestep_view<T> >(n_);
    tstp_=-2;
    nt_=-2;
    ntau_=-1;
    size_=0;
    sig_=-1;    
}
template <typename T> distributed_timestep_array<T>::~distributed_timestep_array(){
    // donothing
}
template <typename T> distributed_timestep_array<T>::distributed_timestep_array(const distributed_timestep_array &a){
    // default
    n_=a.n();
    tid_=a.tid();
    ntasks_=a.ntasks();
    data_=a.data(); // note: this copies the data of a
    tstp_=a.tstp();
    nt_=a.nt();
    ntau_=a.ntau();
    size_=a.size();
    sig_=a.sig();
    G_=a.G(); // this copies only the pointers of G_[j], they still point to the data of a
    // reset G_[j] to point to the new data
    for(int j=0;j<n_;j++) G_[j].set_to_data(data_.block(j),tstp_,ntau_,size_,sig_);
}
template <typename T> distributed_timestep_array<T>& distributed_timestep_array<T>::operator=(const distributed_timestep_array &a){
    if(this==&a) return *this;
    n_=a.n();
    tid_=a.tid();
    ntasks_=a.ntasks();
    data_=a.data(); // note: this copies the data of a
    tstp_=a.tstp();
    nt_=a.nt();
    ntau_=a.ntau();
    size_=a.size();
    sig_=a.sig();
    G_=a.G(); // this copies only the poiters of G_[j], they still point to the data of a
    // reset G_[j] to point to the new data
    for(int j=0;j<n_;j++) G_[j].set_to_data(data_.block(j),tstp_,ntau_,size_,sig_);
    return *this;
}

template <typename T> distributed_timestep_array<T>::distributed_timestep_array(int n,int nt,int ntau,int size,int sig,bool mpi){
    assert(-1<=nt && 0<=ntau &&  sig*sig==1 && 1<=size);
    int size_tstp=(ntau+1+2*(nt+1))*size*size;
    int maxlen=size_tstp;
    data_=cntr::distributed_array<std::complex<T> >(n,maxlen,mpi);
    n_=data_.n();   
    tid_=data_.tid();
    ntasks_=data_.ntasks(); 
    tstp_=-2;
    nt_=nt;
    ntau_=ntau;
    size_=size;
    sig_=sig;
    // they all point nowhere, since tstp=-2
    G_=std::vector<cntr::herm_matrix_timestep_view<T> >(n_);
}

template <typename T> void distributed_timestep_array<T>::reset_tstp(int tstp){
    assert(-1<=tstp && -1<=nt_);
    int blocksize=(ntau_+1+2*(tstp+1))*size_*size_;
    tstp_=tstp;
    data_.reset_blocksize(blocksize);
    for(int j=0;j<n_;j++) G_[j].set_to_data(data_.block(j),tstp_,ntau_,size_,sig_);
}

template <typename T> void distributed_timestep_array<T>::clear(void){
    data_.clear();
}

template <typename T> cntr::herm_matrix_timestep_view<T>& distributed_timestep_array<T>::G(int j){
    assert(0<=j && 0<=n_-1);
    return G_[j];
}

template <typename T> void distributed_timestep_array<T>::mpi_bcast_block(int j){
    data_.mpi_bcast_block(j);
}

template <typename T> void distributed_timestep_array<T>::mpi_bcast_all(void){
    data_.mpi_bcast_all();
}

}
#endif