mltply.cpp

Go to the documentation of this file.

/* HPhi  -  Quantum Lattice Model Simulator */
/* Copyright (C) 2015 The University of Tokyo */
/* 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/>. */

// Define Mode for mltply
// complex version
#include <bitcalc.hpp>
#include "mltply.hpp"
#include "mltplySpin.hpp"
#include "mltplyHubbard.hpp"
#include "wrapperMPI.hpp"
#include "CalcTime.hpp"
#include "mltplyCommon.hpp"
#include "diagonalcalc.hpp"

int mltply(struct BindStruct *X, int nstate, std::complex<double> **tmp_v0,std::complex<double> **tmp_v1) {
  int one = 1;
  long int j=0;
  long int irght=0;
  long int ilft=0;
  long int ihfbit=0;
  std::complex<double> dmv;


  long int i_max;

  StartTimer(1);
  i_max = X->Check.idim_max;

  if (X->Def.iFlgGeneralSpin == FALSE) {
    if (GetSplitBitByModel(X->Def.Nsite, X->Def.iCalcModel, &irght, &ilft, &ihfbit) != 0) {
      return -1;
    }
  }
  else {
    if (X->Def.iCalcModel == Spin) {
      if (GetSplitBitForGeneralSpin(X->Def.Nsite, &ihfbit, X->Def.SiteToBit) != 0) {
        return -1;
      }
    }
  }  
 
  X->Large.i_max = i_max;
  X->Large.irght = irght;
  X->Large.ilft = ilft;
  X->Large.ihfbit = ihfbit;
  X->Large.mode = M_MLTPLY;

  StartTimer(100);
#pragma omp parallel for default(none) private(dmv) \
  firstprivate(i_max) shared(tmp_v0, tmp_v1, list_Diagonal,one,nstate)
  for (j = 1; j <= i_max; j++) {
    dmv = list_Diagonal[j];
    zaxpy_(&nstate, &dmv, &tmp_v1[j][0], &one, &tmp_v0[j][0], &one);
  }
  StopTimer(100);
  if (X->Def.iCalcType == TimeEvolution) diagonalcalcForTE(step_i, X, &tmp_v0[0][0], &tmp_v1[0][0]);
  
  switch (X->Def.iCalcModel) {
  case HubbardGC:
    mltplyHubbardGC(X, nstate, tmp_v0, tmp_v1);
    break;
      
  case KondoGC:
  case Hubbard:
  case Kondo:
    mltplyHubbard(X, nstate, tmp_v0, tmp_v1);
    break;
      
  case Spin:
    mltplySpin(X, nstate, tmp_v0, tmp_v1);
    break;
      
  case SpinGC:
    mltplySpinGC(X, nstate, tmp_v0, tmp_v1);
    break;
      
  default:
    return -1;
  }
  
  StopTimer(1);
  return 0;
}
void zaxpy_long(
  long int n, 
  std::complex<double> a, 
  std::complex<double> *x, 
  std::complex<double> *y
) {
  long int i;

#pragma omp parallel for default(none) private(i) shared(n, a, x, y)
  for (i = 0; i < n; i++) 
    y[i] += a * x[i];
}
void zclear(
  long int n,
  std::complex<double> *x
) {
  long int i;

#pragma omp parallel for default(none) private(i) shared(n, x)
  for (i = 0; i < n; i++) 
    x[i] = 0.0;
}