cntr_mpitools_impl.hpp

Go to the documentation of this file.

#ifndef CNTR_MPITOOLS_IMPL_H
#define CNTR_MPITOOLS_IMPL_H

#include "cntr_mpitools_decl.hpp"
#include "cntr_herm_matrix_decl.hpp"
#include "cntr_herm_matrix_timestep_decl.hpp"
#include "cntr_herm_matrix_timestep_view_decl.hpp"
#include "cntr_herm_matrix_timestep_view_impl.hpp"

namespace cntr{

template <typename T> void Reduce_timestep(int tstp, int root, herm_matrix_timestep<T> &Gred, 
    herm_matrix_timestep<T> &G){
    assert(tstp == G.tstp()); 
    int taskid;
    MPI_Comm_rank(MPI_COMM_WORLD, &taskid);
    if (taskid == root) {
        assert(tstp == Gred.tstp());
        assert(G.ntau() == Gred.ntau());
        assert(G.size1() == Gred.size1());
        assert(G.size2() == Gred.size2());
    }

    int len = 2 * (2 * (tstp + 1) + G.ntau() + 1) * G.size1() * G.size2();

    if (sizeof(T) == sizeof(double)) {
        MPI_Reduce((double *)G.data_, (double *)Gred.data_, len, MPI_DOUBLE_PRECISION, MPI_SUM, root,
           MPI_COMM_WORLD);
   } else {
      if (taskid == root) std::cerr << "herm_matrix_timestep<T>::MPI_Reduce only for double " << std::endl;
      MPI_Finalize();
      exit(0);
   }

}


template <typename T> void Reduce_timestep(int tstp, int root, herm_matrix_timestep_view<T> &Gred, 
    herm_matrix_timestep_view<T> &G){
    assert(tstp == G.tstp());
    int taskid;
    MPI_Comm_rank(MPI_COMM_WORLD, &taskid);
    if (taskid == root) {
        assert(tstp == Gred.tstp());
        assert(G.ntau() == Gred.ntau());
        assert(G.size1() == Gred.size1());
        assert(G.size2() == Gred.size2());
    }

    int len_rt = 2 * (tstp + 1) * G.size1() * G.size2();
    int len_it = 2 * (G.ntau() + 1) * G.size1() * G.size2();

    if (sizeof(T) == sizeof(double)) {
        if(tstp == -1){
            MPI_Reduce((double *)G.mat_, (double *)Gred.mat_, len_it, MPI_DOUBLE_PRECISION, MPI_SUM, root,
                MPI_COMM_WORLD);
        } else{
            MPI_Reduce((double *)G.les_, (double *)Gred.les_, len_rt, MPI_DOUBLE_PRECISION, MPI_SUM, root,
                MPI_COMM_WORLD);
            MPI_Reduce((double *)G.ret_, (double *)Gred.ret_, len_rt, MPI_DOUBLE_PRECISION, MPI_SUM, root,
                MPI_COMM_WORLD);
            MPI_Reduce((double *)G.tv_, (double *)Gred.tv_, len_it, MPI_DOUBLE_PRECISION, MPI_SUM, root,
                MPI_COMM_WORLD);
        }
        
   } else {
      if (taskid == root) std::cerr << "herm_matrix_timestep_view<T>::MPI_Reduce only for double " << std::endl;
      MPI_Finalize();
      exit(0);
   }

}


template <typename T> void Reduce_timestep(int tstp, int root, herm_matrix<T> &Gred, 
    herm_matrix_timestep<T> &G){
    assert(tstp == G.tstp());
    int taskid;
    MPI_Comm_rank(MPI_COMM_WORLD, &taskid);
    if (taskid == root) {
        assert(tstp <= Gred.nt());
        assert(G.ntau() == Gred.ntau());
        assert(G.size1() == Gred.size1());
        assert(G.size2() == Gred.size2());
    }

    herm_matrix_timestep<T> Gtemp;
    if (taskid == root){
        Gtemp.resize(tstp, G.ntau(), G.size1());
    }

    Reduce_timestep(tstp, root, Gtemp, G);

    if (taskid == root){
        Gred.set_timestep(tstp, Gtemp);
    }
}


template <typename T> void Reduce_timestep(int tstp, int root, herm_matrix<T> &Gred, 
    herm_matrix_timestep_view<T> &G){
    assert(tstp == G.tstp());
    int taskid;
    MPI_Comm_rank(MPI_COMM_WORLD, &taskid);
    if (taskid == root) {
        assert(tstp <= Gred.nt());
        assert(G.ntau() == Gred.ntau());
        assert(G.size1() == Gred.size1());
        assert(G.size2() == Gred.size2());
    }

    bool check_tstp = (taskid == root);
    herm_matrix_timestep_view<T> Gred_tmp(tstp, Gred, check_tstp);
    Reduce_timestep(tstp, root, Gred_tmp, G);

}



template <typename T> void Reduce_timestep(int tstp, int root, herm_matrix_timestep<T> &Gred, 
    herm_matrix<T> &G){
    assert(tstp <= G.nt());
    int taskid;
    MPI_Comm_rank(MPI_COMM_WORLD, &taskid);
    if (taskid == root) {
        assert(tstp == Gred.tstp());
        assert(G.ntau() == Gred.ntau());
        assert(G.size1() == Gred.size1());
        assert(G.size2() == Gred.size2());
    }

    herm_matrix_timestep<T> Gtemp;
    Gtemp.resize(tstp, G.ntau(), G.size1());
    G.get_timestep(tstp, Gtemp);

    Reduce_timestep(tstp, root, Gred, Gtemp);

}

template <typename T> void Reduce_timestep(int tstp, int root, herm_matrix_timestep_view<T> &Gred, 
    herm_matrix<T> &G){
    assert(tstp <= G.nt());
    int taskid;
    MPI_Comm_rank(MPI_COMM_WORLD, &taskid);
    if (taskid == root) {
        assert(tstp == Gred.tstp());
        assert(G.ntau() == Gred.ntau());
        assert(G.size1() == Gred.size1());
        assert(G.size2() == Gred.size2());
    }

    herm_matrix_timestep_view<T> Gtemp(tstp, G);
    Reduce_timestep(tstp, root, Gred, Gtemp);

}


template <typename T> void Reduce_timestep(int tstp, int root, herm_matrix<T> &Gred, 
    herm_matrix<T> &G){
    assert(tstp <= G.nt());
    int taskid;
    MPI_Comm_rank(MPI_COMM_WORLD, &taskid);
    if (taskid == root) {
        assert(tstp <= Gred.nt());
        assert(G.ntau() == Gred.ntau());
        assert(G.size1() == Gred.size1());
        assert(G.size2() == Gred.size2());
    }

    bool check_tstp = (taskid == root);
    herm_matrix_timestep_view<T> Gred_tmp(tstp, Gred, check_tstp);
    herm_matrix_timestep_view<T> Garr_tmp(tstp, G);

    Reduce_timestep(tstp, root, Gred_tmp, Garr_tmp);
}



} // namespace cntr


#endif // CNTR_MPITOOLS_IMPL_H