QMCSlater.h

Go to the documentation of this file.

//            QMcBeaver
//
//         Constructed by 
//
//     Michael Todd Feldmann 
//              and 
//   David Randall "Chip" Kent IV
//
// Copyright 2000.  All rights reserved.
//
// drkent@users.sourceforge.net mtfeldmann@users.sourceforge.net

/**************************************************************************
This SOFTWARE has been authored or contributed to by an employee or 
employees of the University of California, operator of the Los Alamos 
National Laboratory under Contract No. W-7405-ENG-36 with the U.S. 
Department of Energy.  The U.S. Government has rights to use, reproduce, 
and distribute this SOFTWARE.  Neither the Government nor the University 
makes any warranty, express or implied, or assumes any liability or 
responsibility for the use of this SOFTWARE.  If SOFTWARE is modified 
to produce derivative works, such modified SOFTWARE should be clearly 
marked, so as not to confuse it with the version available from LANL.   

Additionally, this program is free software; you can distribute it and/or 
modify it under the terms of the GNU General Public License. Accordingly, 
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. 
**************************************************************************/

#ifndef QMCSLATER_H
#define QMCSLATER_H

#include <iostream>

#include "Array1D.h"
#include "Array2D.h"
#include "Array3D.h"
#include "Array4D.h"
#include "QMCInput.h"
#include "Stopwatch.h"
#include "QMCElectronNucleusCusp.h"
#include "svdcmp.h"
#include "QMCWalkerData.h"

#ifdef QMC_GPU
#include "GPUQMCMatrix.h"
#include "GPUQMCBasisFunction.h"
#endif

using namespace std;

class QMCSlater
{
public:
  QMCSlater();

  ~QMCSlater();

  void initialize(QMCInput *input, int startEl, int stopEl, bool isAlpha);

  void evaluate(Array1D<Array2D<double>*> & X,
                int num, int start, int whichE);

  void update_Ds(Array1D<QMCWalkerData *> & walkerData);

  template <class T>
    bool calculate_DerivativeRatios(int ci, int row,
                                    Array2D<double> & psi,
                                    Array2D<double> & inv,
                                    Array2D<T> & lap,
                                    Array2D<T> & gradx,
                                    Array2D<T> & grady,
                                    Array2D<T> & gradz,
                                    Array1D<double> & det,
                                    Array3D<double> & gradPR,
                                    Array1D<double> & lapPR);    
  
#ifdef QMC_GPU
  /*
    This function is pure GPU calculations. 

    @param num how many configurations to process in the X array.
    @param X the array of electronic positions indexed by their walker
  */
  void gpuEvaluate(Array1D<Array2D<double>*> &X, int num);
#endif


  Array1D<double>* getPsi(int i);

  Array3D<double>* getGradPsiRatio(int i);

  Array1D<double>* getLaplacianPsiRatio(int i);
  
  Array2D<double> * get_p_a(int walker, int ci)
    {
      return  & (p_a(walker))(ci);
    }
  
  Array2D<double> * get_p2_xa(int walker, int ci, int el, int xyz)
    {
      return & (p2_xa(walker))(ci,el,xyz);
    }

  Array2D<double> * get_p3_xxa(int walker, int ci)
    {
      return & (p3_xxa(walker))(ci);
    }

  Array1D<double>* getChiDensity(int i);

  bool isSingular(int i);

  void operator=(const QMCSlater & rhs );

#ifdef QMC_GPU
  GPUQMCBasisFunction gpuBF;
  GPUQMCMatrix gpuMatMult;
#endif

 private:
  bool isAlpha;

  QMCInput *Input;
  QMCBasisFunction *BF;
  QMCWavefunction  *WF;
  
  Array1D< Array1D< Array2D<double> > > p_a;
  Array1D< Array3D< Array2D<double> > > p2_xa;
  Array1D< Array1D< Array2D<double> > > p3_xxa;

  int Start;
  int Stop;

  QMCElectronNucleusCusp ElectronNucleusCusp;

  Array1D<          Array2D<qmcfloat>   >  Xw;
  Array1D< Array1D< Array2D<qmcfloat> > >  Xw_x;
  Array1D<          Array2D<qmcfloat>   >  Xw_xx;
  Array1D< Array1D<double> >               Xw_Density;

  Array2D< double > * ciDet;
  Array1D< Array2D<qmcfloat> > Dw;
  Array2D< Array2D<qmcfloat> > Dw_x;
  Array1D< Array2D<qmcfloat> > Dw_xx;
  Array2D< Array2D<double>   > Dwc_inv;

  Array1D< Array1D<double> > Dwc;
  Array1D< Array3D<double> > rDwc_x;
  Array1D< Array1D<double> > rDwc_xx;
  Array1D< Array1D<bool> >   Singular;

  Array1D< Array1D<double> * > pointer_Dwc;
  Array1D< Array3D<double> * > pointer_rDwc_x;
  Array1D< Array1D<double> * > pointer_rDwc_xx;

#ifdef QMC_GPU

  Array1D< Array2D<float> > gpu_Dw;
  Array2D< Array2D<float> > gpu_Dw_inv;
  Array1D< Array2D<float> > gpu_Dw_xx;
  Array2D< Array2D<float> > gpu_Dw_x;

  Array2D< Array2D<float>* > resultsCollector;
#endif

  /*
    This function will make sure that
    all the data structures have the right dimensions
    for either matrix-matrix multiplication or
    vector-matrix multiplication.

    @param whichE the whichE index provided to evaluate
    @param start will be assigned which electron to start the update
    @param stop will be assigned which electron to stop the update
  */
  void allocateIteration(int whichE, int & start, int & stop);

  void allocate();

  int getNumberElectrons()
    {
      return Stop-Start+1;
    }
};

#endif

---