Merge remote-tracking branch 'origin/develop' into vext

src/AngleConstraint.C

@@ -12,10 +12,9 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 //
-//  AngleConstraint.C
+// AngleConstraint.C
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: AngleConstraint.C,v 1.6 2008-09-08 15:56:17 fgygi Exp $
 
 #include "AngleConstraint.h"
 #include "AtomSet.h"

src/AngleConstraint.h

@@ -12,10 +12,9 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 //
-//  AngleConstraint.h
+// AngleConstraint.h
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: AngleConstraint.h,v 1.8 2009-05-15 04:38:48 fgygi Exp $
 
 #ifndef ANGLECONSTRAINT_H
 #define ANGLECONSTRAINT_H

src/Atom.C

@@ -15,7 +15,6 @@
 // Atom.C:
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: Atom.C,v 1.5 2008-09-08 15:56:17 fgygi Exp $
 
 #include "Atom.h"
 #include <iomanip>

src/Atom.h

@@ -15,7 +15,6 @@
 // Atom.h:
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: Atom.h,v 1.6 2008-09-08 15:56:17 fgygi Exp $
 
 #ifndef ATOM_H
 #define ATOM_H

src/AtomCmd.h

@@ -15,7 +15,6 @@
 // AtomCmd.h:
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: AtomCmd.h,v 1.11 2009-08-14 17:06:43 fgygi Exp $
 
 #ifndef ATOMCMD_H
 #define ATOMCMD_H

src/AtomSetHandler.h

@@ -15,7 +15,6 @@
 // AtomSetHandler.h
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: AtomSetHandler.h,v 1.5 2008-09-08 15:56:18 fgygi Exp $
 
 #ifndef ATOMSETHANDLER_H
 #define ATOMSETHANDLER_H

src/AtomicExtForce.C

@@ -12,10 +12,9 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 //
-//  AtomicExtForce.C
+// AtomicExtForce.C
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: AtomicExtForce.C,v 1.1 2010-02-20 23:13:02 fgygi Exp $
 
 #include "AtomicExtForce.h"
 #include "AtomSet.h"

src/AtomicExtForce.h

@@ -12,10 +12,9 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 //
-//  AtomicExtForce.h
+// AtomicExtForce.h
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: AtomicExtForce.h,v 1.1 2010-02-20 23:13:02 fgygi Exp $
 
 #ifndef ATOMICEXTFORCE_H
 #define ATOMICEXTFORCE_H

src/AtomsDyn.h

@@ -15,7 +15,6 @@
 // AtomsDyn.h
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: AtomsDyn.h,v 1.7 2009-04-30 22:22:23 fgygi Exp $
 
 #ifndef ATOMSDYN_H
 #define ATOMSDYN_H

src/BOSampleStepper.C

@@ -60,10 +60,10 @@ BOSampleStepper::~BOSampleStepper()
     s_.ctxt_.dmax(1,1,&tmax,1);
     if ( s_.ctxt_.myproc()==0 )
     {
-      cout << "<timing name=\""
-           << setw(15) << (*i).first << "\""
-           << " min=\"" << setprecision(3) << setw(9) << tmin << "\""
-           << " max=\"" << setprecision(3) << setw(9) << tmax << "\"/>"
+      string s = "name=\"" + (*i).first + "\"";
+      cout << "<timing " << left << setw(22) << s
+           << " min=\"" << setprecision(3) << tmin << "\""
+           << " max=\"" << setprecision(3) << tmax << "\"/>"
            << endl;
     }
   }
@@ -1209,9 +1209,10 @@ void BOSampleStepper::step(int niter)
     s_.ctxt_.dmax(1,1,&tmax,1);
     if ( onpe0 )
     {
-      cout << "  <timing name=\"iteration\""
-           << " min=\"" << setprecision(3) << setw(9) << tmin << "\""
-           << " max=\"" << setprecision(3) << setw(9) << tmax << "\"/>"
+      string s = "name=\"iteration\"";
+      cout << "<timing " << left << setw(22) << s
+           << " min=\"" << setprecision(3) << tmin << "\""
+           << " max=\"" << setprecision(3) << tmax << "\"/>"
            << endl;
       cout << "</iteration>" << endl;
     }

src/Base64Transcoder.h

@@ -15,7 +15,6 @@
 // Base64Transcoder.h
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: Base64Transcoder.h,v 1.7 2008-09-08 15:56:18 fgygi Exp $
 
 #ifndef BASE64TRANSCODER_H
 #define BASE64TRANSCODER_H

src/Basis.h

@@ -12,7 +12,7 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 //
-//  Basis.h
+// Basis.h
 //
 ////////////////////////////////////////////////////////////////////////////////
 

src/BasisMapping.C

@@ -12,7 +12,7 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 //
-//  BasisMapping.C
+// BasisMapping.C
 //
 ////////////////////////////////////////////////////////////////////////////////
 

src/BasisMapping.h

@@ -12,7 +12,7 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 //
-//  BasisMapping.h
+// BasisMapping.h
 //
 ////////////////////////////////////////////////////////////////////////////////
 

src/Bisection.C

@@ -434,10 +434,10 @@ void Bisection::compute_transform(const SlaterDet& sd, int maxsweep, double tol)
     ctxt_.dmax(1,1,&tmax,1);
     if ( ctxt_.myproc()==0 )
     {
-      cout << "<timing name=\""
-           << setw(15) << (*i).first << "\""
-           << " min=\"" << setprecision(3) << setw(9) << tmin << "\""
-           << " max=\"" << setprecision(3) << setw(9) << tmax << "\"/>"
+      string s = "name=\"" + (*i).first + "\"";
+      cout << "<timing " << left << setw(22) << s
+           << " min=\"" << setprecision(3) << tmin << "\""
+           << " max=\"" << setprecision(3) << tmax << "\"/>"
            << endl;
     }
   }

src/BisectionCmd.h

@@ -83,8 +83,8 @@ class BisectionCmd : public Cmd
       {
         cout << " BisectionCmd: lx=" << nLevels[0]
              << " ly=" << nLevels[1]
-	     << " lz=" << nLevels[2]
-	     << " threshold=" << epsilon << endl;
+             << " lz=" << nLevels[2]
+             << " threshold=" << epsilon << endl;
 
         // print localization vectors and overlaps
         int sum = 0;

src/CPSampleStepper.C

@@ -69,10 +69,10 @@ CPSampleStepper::~CPSampleStepper(void)
     s_.ctxt_.dmax(1,1,&tmax,1);
     if ( s_.ctxt_.myproc()==0 )
     {
-      cout << "<timing name=\""
-           << setw(15) << (*i).first << "\""
-           << " min=\"" << setprecision(3) << setw(9) << tmin << "\""
-           << " max=\"" << setprecision(3) << setw(9) << tmax << "\"/>"
+      string s = "name=\"" + (*i).first + "\"";
+      cout << "<timing " << left << setw(22) << s
+           << " min=\"" << setprecision(3) << tmin << "\""
+           << " max=\"" << setprecision(3) << tmax << "\"/>"
            << endl;
     }
   }
@@ -268,9 +268,10 @@ void CPSampleStepper::step(int niter)
     s_.ctxt_.dmax(1,1,&tmax,1);
     if ( s_.ctxt_.myproc()==0 )
     {
-      cout << "  <timing name=\"iteration\""
-           << " min=\"" << setprecision(3) << setw(9) << tmin << "\""
-           << " max=\"" << setprecision(3) << setw(9) << tmax << "\"/>"
+      string s = "name=\"iteration\"";
+      cout << "<timing " << left << setw(22) << s
+           << " min=\"" << setprecision(3) << tmin << "\""
+           << " max=\"" << setprecision(3) << tmax << "\"/>"
            << endl;
     }
     if ( compute_forces )

src/CPSampleStepper.h

@@ -15,7 +15,6 @@
 // CPSampleStepper.h
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: CPSampleStepper.h,v 1.7 2008-09-08 15:56:18 fgygi Exp $
 
 #ifndef CPSAMPLESTEPPER_H
 #define CPSAMPLESTEPPER_H

src/Cell.h

@@ -15,7 +15,6 @@
 // Cell.h
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: Cell.h,v 1.9 2008-09-08 15:56:18 fgygi Exp $
 
 #ifndef CELL_H
 #define CELL_H

src/CellLock.h

@@ -15,7 +15,6 @@
 // CellLock.h
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: CellLock.h,v 1.6 2008-09-08 15:56:18 fgygi Exp $
 
 #ifndef CELLLOCK_H
 #define CELLLOCK_H

src/CellMass.h

@@ -15,7 +15,6 @@
 // CellMass.h
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: CellMass.h,v 1.4 2008-09-08 15:56:18 fgygi Exp $
 
 #ifndef CELLMASS_H
 #define CELLMASS_H

src/ChargeDensity.C

@@ -109,10 +109,10 @@ ChargeDensity::~ChargeDensity(void)
     ctxt_.dmax(1,1,&tmax,1);
     if ( ctxt_.myproc()==0 )
     {
-      cout << "<timing name=\""
-           << setw(15) << (*i).first << "\""
-           << " min=\"" << setprecision(3) << setw(9) << tmin << "\""
-           << " max=\"" << setprecision(3) << setw(9) << tmax << "\"/>"
+      string s = "name=\"" + (*i).first + "\"";
+      cout << "<timing " << left << setw(22) << s
+           << " min=\"" << setprecision(3) << tmin << "\""
+           << " max=\"" << setprecision(3) << tmax << "\"/>"
            << endl;
     }
   }

src/ChargeMixCoeff.h

@@ -15,7 +15,6 @@
 // ChargeMixCoeff.h
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: ChargeMixCoeff.h,v 1.6 2008-09-08 15:56:18 fgygi Exp $
 
 #ifndef CHARGEMIXCOEFF_H
 #define CHARGEMIXCOEFF_H

src/ChargeMixNdim.h

@@ -15,7 +15,6 @@
 // ChargeMixNdim.h
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: ChargeMixNdim.h,v 1.1 2009-03-08 01:09:58 fgygi Exp $
 
 #ifndef CHARGEMIXNDIM_H
 #define CHARGEMIXNDIM_H

src/ChargeMixRcut.h

@@ -15,7 +15,6 @@
 // ChargeMixRcut.h
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: ChargeMixRcut.h,v 1.4 2008-09-08 15:56:18 fgygi Exp $
 
 #ifndef CHARGEMIXRCUT_H
 #define CHARGEMIXRCUT_H

src/ComputeMLWFCmd.h

@@ -15,7 +15,6 @@
 // ComputeMLWFCmd.h
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: ComputeMLWFCmd.h,v 1.5 2008-11-14 22:11:30 fgygi Exp $
 
 #ifndef COMPUTEMLWFCMD_H
 #define COMPUTEMLWFCMD_H

src/ConfinementPotential.C

@@ -15,7 +15,6 @@
 // ConfinementPotential.C
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: ConfinementPotential.C,v 1.4 2008-09-08 15:56:18 fgygi Exp $
 
 #include "ConfinementPotential.h"
 #include "Basis.h"

src/ConfinementPotential.h

@@ -15,7 +15,6 @@
 // ConfinementPotential.h
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: ConfinementPotential.h,v 1.7 2008-09-08 15:56:18 fgygi Exp $
 
 #ifndef CONFINEMENTPOTENTIAL_H
 #define CONFINEMENTPOTENTIAL_H

src/Constraint.C

@@ -12,10 +12,9 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 //
-//  Constraint.C
+// Constraint.C
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: Constraint.C,v 1.4 2008-09-08 15:56:18 fgygi Exp $
 
 #include "Constraint.h"
 #include <iostream>

src/Constraint.h

@@ -12,10 +12,9 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 //
-//  Constraint.h
+// Constraint.h
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: Constraint.h,v 1.8 2009-05-15 04:38:48 fgygi Exp $
 
 #ifndef CONSTRAINT_H
 #define CONSTRAINT_H

src/ConstraintCmd.h

@@ -15,7 +15,6 @@
 // ConstraintCmd.h:
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: ConstraintCmd.h,v 1.6 2009-04-30 22:24:08 fgygi Exp $
 
 #ifndef CONSTRAINTCMD_H
 #define CONSTRAINTCMD_H

src/ConstraintSet.h

@@ -15,7 +15,6 @@
 // ConstraintSet.h
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: ConstraintSet.h,v 1.10 2010-02-20 23:13:02 fgygi Exp $
 
 #ifndef CONSTRAINTSET_H
 #define CONSTRAINTSET_H

src/Debug.h

@@ -15,7 +15,6 @@
 // Debug.h
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: Debug.h,v 1.5 2008-09-08 15:56:18 fgygi Exp $
 
 #ifndef DEBUG_H
 #define DEBUG_H

src/DistanceConstraint.C

@@ -12,10 +12,9 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 //
-//  DistanceConstraint.C
+// DistanceConstraint.C
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: DistanceConstraint.C,v 1.6 2008-09-08 15:56:18 fgygi Exp $
 
 #include "DistanceConstraint.h"
 #include "AtomSet.h"

src/DistanceConstraint.h

@@ -12,10 +12,9 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 //
-//  DistanceConstraint.h
+// DistanceConstraint.h
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: DistanceConstraint.h,v 1.8 2009-05-15 04:38:48 fgygi Exp $
 
 #ifndef DISTANCECONSTRAINT_H
 #define DISTANCECONSTRAINT_H

src/Dt.h

@@ -15,7 +15,6 @@
 // Dt.h
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: Dt.h,v 1.5 2008-09-08 15:56:18 fgygi Exp $
 
 #ifndef DT_H
 #define DT_H

src/Ecut.h

@@ -15,7 +15,6 @@
 // Ecut.h
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: Ecut.h,v 1.8 2008-09-08 15:56:18 fgygi Exp $
 
 #ifndef ECUT_H
 #define ECUT_H

src/Ecutprec.h

@@ -15,7 +15,6 @@
 // Ecutprec.h
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: Ecutprec.h,v 1.4 2008-09-08 15:56:18 fgygi Exp $
 
 #ifndef ECUTPREC_H
 #define ECUTPREC_H

src/Ecuts.h

@@ -15,7 +15,6 @@
 // Ecuts.h
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: Ecuts.h,v 1.4 2008-09-08 15:56:18 fgygi Exp $
 
 #ifndef ECUTS_H
 #define ECUTS_H

src/ElectricEnthalpy.C

@@ -162,10 +162,10 @@ ElectricEnthalpy::~ElectricEnthalpy(void)
     s_.ctxt_.dmax(1,1,&tmax,1);
     if ( pol_type_ != off && s_.ctxt_.myproc()==0 )
     {
-      cout << "<timing name=\""
-           << setw(15) << (*i).first << "\""
-           << " min=\"" << setprecision(3) << setw(9) << tmin << "\""
-           << " max=\"" << setprecision(3) << setw(9) << tmax << "\"/>"
+      string s = "name=\"" + (*i).first + "\"";
+      cout << "<timing " << left << setw(22) << s
+           << " min=\"" << setprecision(3) << tmin << "\""
+           << " max=\"" << setprecision(3) << tmax << "\"/>"
            << endl;
     }
   }

src/Emass.h

@@ -15,7 +15,6 @@
 // Emass.h
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: Emass.h,v 1.5 2009-05-15 04:40:52 fgygi Exp $
 
 #ifndef EMASS_H
 #define EMASS_H

src/EnergyFunctional.C

@@ -216,10 +216,10 @@ EnergyFunctional::~EnergyFunctional(void)
     s_.ctxt_.dmax(1,1,&tmax,1);
     if ( s_.ctxt_.myproc()==0 )
     {
-      cout << "<timing name=\""
-           << setw(15) << (*i).first << "\""
-           << " min=\"" << setprecision(3) << setw(9) << tmin << "\""
-           << " max=\"" << setprecision(3) << setw(9) << tmax << "\"/>"
+      string s = "name=\"" + (*i).first + "\"";
+      cout << "<timing " << left << setw(22) << s
+           << " min=\"" << setprecision(3) << tmin << "\""
+           << " max=\"" << setprecision(3) << tmax << "\"/>"
            << endl;
     }
   }

src/ExchangeOperator.C

@@ -795,7 +795,7 @@ double ExchangeOperator::compute_exchange_for_general_case_( Sample* s,
         const double div_corr_1 = exfac * numerical_correction[iKpi] *
                                   occ_ki_[i];
         div_corr += div_corr_1;
-        const double e_div_corr_1 = -div_corr_1;
+        const double e_div_corr_1 = -0.5 * div_corr_1 * occ_ki_[i];
         exchange_sum += e_div_corr_1 * wf.weight(iKpi);
         // add here contributions to stress from div_corr_1;
 

src/ExtForce.C

@@ -12,10 +12,9 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 //
-//  ExtForce.C
+// ExtForce.C
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: ExtForce.C,v 1.1 2010-02-20 23:13:02 fgygi Exp $
 
 #include "ExtForce.h"
 #include <iostream>

src/ExtForce.h

@@ -12,10 +12,9 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 //
-//  ExtForce.h
+// ExtForce.h
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: ExtForce.h,v 1.1 2010-02-20 23:13:02 fgygi Exp $
 
 #ifndef EXTFORCE_H
 #define EXTFORCE_H

src/ExtForceCmd.h

@@ -15,7 +15,6 @@
 // ExtForceCmd.h:
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: ExtForceCmd.h,v 1.1 2010-02-20 23:13:02 fgygi Exp $
 
 #ifndef EXTFORCECMD_H
 #define EXTFORCECMD_H

src/ExtForceSet.C

@@ -15,7 +15,6 @@
 // ExtForceSet.C
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: ExtForceSet.C,v 1.1 2010-02-20 23:13:02 fgygi Exp $
 
 #include "ExtForceSet.h"
 #include "AtomicExtForce.h"

src/ExtForceSet.h

@@ -15,7 +15,6 @@
 // ExtForceSet.h
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: ExtForceSet.h,v 1.1 2010-02-20 23:13:02 fgygi Exp $
 
 #ifndef EXTFORCESET_H
 #define EXTFORCESET_H

src/ExtStress.h

@@ -15,7 +15,6 @@
 // ExtStress.h
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: ExtStress.h,v 1.5 2008-09-08 15:56:18 fgygi Exp $
 
 #ifndef EXTSTRESS_H
 #define EXTSTRESS_H

src/FermiTemp.h

@@ -15,7 +15,6 @@
 // FermiTemp.h
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: FermiTemp.h,v 1.4 2008-09-08 15:56:18 fgygi Exp $
 
 #ifndef FERMITEMP_H
 #define FERMITEMP_H

src/FoldInWsCmd.h

@@ -15,7 +15,6 @@
 // FoldInWsCmd.h:
 //
 ////////////////////////////////////////////////////////////////////////////////
-// $Id: FoldInWsCmd.h,v 1.3 2008-09-08 15:56:18 fgygi Exp $
 
 #ifndef FOLDINWSCMD_H
 #define FOLDINWSCMD_H

src/FourierTransform.C

@@ -589,8 +589,9 @@ void FourierTransform::bwd(complex<double>* val)
   int inc1 = 1, inc2 = np2_, ntrans = nvec_, isign = -1, initflag = 0;
   double scale = 1.0;
 
-  dcft_(&initflag,&zvec_[0],&inc1,&inc2,&zvec_[0],&inc1,&inc2,&np2_,&ntrans,
-       &isign,&scale,&aux1zb[0],&naux1z,&aux2[0],&naux2);
+  if ( ntrans > 0 )
+    dcft_(&initflag,&zvec_[0],&inc1,&inc2,&zvec_[0],&inc1,&inc2,&np2_,&ntrans,
+          &isign,&scale,&aux1zb[0],&naux1z,&aux2[0],&naux2);
 #elif USE_FFTW2
    /*
     * void fftw(fftw_plan plan, int howmany,
@@ -834,29 +835,35 @@ void FourierTransform::bwd(complex<double>* val)
     // transform only non-zero vectors along x
     // First block: positive y indices: [0,ntrans0_]
     ntrans = ntrans0_;
-    inc1 = 1;
-    inc2 = np0_;
-    istart = k * np0_ * np1_;
-    length = np0_;
-    dcft_(&initflag,&val[istart],&inc1,&inc2,&val[istart],&inc1,&inc2,
-         &length,&ntrans,&isign,&scale,&aux1xb[0],&naux1x,&aux2[0],&naux2);
-
-    // Second block: negative y indices: [np1-ntrans0_,np1-1]
-    inc1 = 1;
-    inc2 = np0_;
-    istart = np0_ * ( (np1_-ntrans) + k * np1_ );
-    length = np0_;
-    dcft_(&initflag,&val[istart],&inc1,&inc2,&val[istart],&inc1,&inc2,
-         &length,&ntrans,&isign,&scale,&aux1xb[0],&naux1x,&aux2[0],&naux2);
+    if ( ntrans > 0 )
+    {
+      inc1 = 1;
+      inc2 = np0_;
+      istart = k * np0_ * np1_;
+      length = np0_;
+      dcft_(&initflag,&val[istart],&inc1,&inc2,&val[istart],&inc1,&inc2,
+            &length,&ntrans,&isign,&scale,&aux1xb[0],&naux1x,&aux2[0],&naux2);
+
+      // Second block: negative y indices: [np1-ntrans0_,np1-1]
+      inc1 = 1;
+      inc2 = np0_;
+      istart = np0_ * ( (np1_-ntrans) + k * np1_ );
+      length = np0_;
+      dcft_(&initflag,&val[istart],&inc1,&inc2,&val[istart],&inc1,&inc2,
+            &length,&ntrans,&isign,&scale,&aux1xb[0],&naux1x,&aux2[0],&naux2);
+    }
 
     // transform along y for all values of x
     ntrans = np0_;
-    inc1 = np0_;
-    inc2 = 1;
-    istart = k * np0_ * np1_;
-    length = np1_;
-    dcft_(&initflag,&val[istart],&inc1,&inc2,&val[istart],&inc1,&inc2,
-         &length,&ntrans,&isign,&scale,&aux1yb[0],&naux1y,&aux2[0],&naux2);
+    if ( ntrans > 0 )
+    {
+      inc1 = np0_;
+      inc2 = 1;
+      istart = k * np0_ * np1_;
+      length = np1_;
+      dcft_(&initflag,&val[istart],&inc1,&inc2,&val[istart],&inc1,&inc2,
+            &length,&ntrans,&isign,&scale,&aux1yb[0],&naux1y,&aux2[0],&naux2);
+    }
 #endif // USE_ESSL_2DFFT
   } // k
 
@@ -1062,28 +1069,34 @@ void FourierTransform::fwd(complex<double>* val)
     double scale = 1.0;
     // transform along y for all values of x
     ntrans = np0_;
-    inc1 = np0_;
-    inc2 = 1;
-    istart = k * np0_ * np1_;
-    length = np1_;
-    dcft_(&initflag,&val[istart],&inc1,&inc2,&val[istart],&inc1,&inc2,
-         &length,&ntrans,&isign,&scale,&aux1yf[0],&naux1y,&aux2[0],&naux2);
+    if ( ntrans > 0 )
+    {
+      inc1 = np0_;
+      inc2 = 1;
+      istart = k * np0_ * np1_;
+      length = np1_;
+      dcft_(&initflag,&val[istart],&inc1,&inc2,&val[istart],&inc1,&inc2,
+            &length,&ntrans,&isign,&scale,&aux1yf[0],&naux1y,&aux2[0],&naux2);
+    }
 
     // transform only non-zero vectors along x
     ntrans = ntrans0_;
-    inc1 = 1;
-    inc2 = np0_;
-    istart = k * np0_ * np1_;
-    length = np0_;
-    dcft_(&initflag,&val[istart],&inc1,&inc2,&val[istart],&inc1,&inc2,
-         &length,&ntrans,&isign,&scale,&aux1xf[0],&naux1x,&aux2[0],&naux2);
-
-    inc1 = 1;
-    inc2 = np0_;
-    istart = np0_ * ( (np1_-ntrans) + k * np1_ );
-    length = np0_;
-    dcft_(&initflag,&val[istart],&inc1,&inc2,&val[istart],&inc1,&inc2,
-         &length,&ntrans,&isign,&scale,&aux1xf[0],&naux1x,&aux2[0],&naux2);