hdiff output

r29335/amber_potential.cu 2015-11-17 23:32:29.700098383 +0000 r29334/amber_potential.cu 2015-11-17 23:32:32.012129390 +0000
  6:   6: 
  7: #include "cost_function.h"  7: #include "cost_function.h"
  8: #include "potential.h"  8: #include "potential.h"
  9: #include "gpu.h"  9: #include "gpu.h"
 10:  10: 
 11: AmberPotential::AmberPotential(Printing &debugPrinting, Timer &timer_potential, Cublas &cublas,  11: AmberPotential::AmberPotential(Printing &debugPrinting, Timer &timer_potential, Cublas &cublas, 
 12:                 size_t numDimensions, int nDegFreedom, int nRigidBody, int rigidMaxSite,  12:                 size_t numDimensions, int nDegFreedom, int nRigidBody, int rigidMaxSite, 
 13:                 int *nRigidSitesPerBody, int *rigidGroups, double *sitesRigidBody, int *rigidSingles,  13:                 int *nRigidSitesPerBody, int *rigidGroups, double *sitesRigidBody, int *rigidSingles, 
 14:                 double *rigidInverse, double *x, int nSecDiag, bool isAtomisticNotRigid,  14:                 double *rigidInverse, double *x, int nSecDiag, bool isAtomisticNotRigid, 
 15:                 double aaConvThreshold, double coldFusionLim, bool shouldFreeze, bool *isAtomFrozen,  15:                 double aaConvThreshold, double coldFusionLim, bool shouldFreeze, bool *isAtomFrozen, 
 16:                 int nFreeze, bool isAaConvergence) 16:                 int nFreeze)
 17:         : CostFunction(debugPrinting, timer_potential, cublas, numDimensions, nDegFreedom, nRigidBody, rigidMaxSite,  17:         : CostFunction(debugPrinting, timer_potential, cublas, numDimensions, nDegFreedom, nRigidBody, rigidMaxSite, 
 18:                         nRigidSitesPerBody, rigidGroups, sitesRigidBody, rigidSingles, rigidInverse, x, nSecDiag,  18:                         nRigidSitesPerBody, rigidGroups, sitesRigidBody, rigidSingles, rigidInverse, x, nSecDiag, 
 19:                         isAtomisticNotRigid, aaConvThreshold, coldFusionLim, shouldFreeze, isAtomFrozen, nFreeze,  19:                         isAtomisticNotRigid, aaConvThreshold, coldFusionLim, shouldFreeze, isAtomFrozen, nFreeze) {}
 20:                         isAaConvergence) {} 
 21:  20: 
 22:  21: 
 23:  22: 
 24: void AmberPotential::computeEnergyAndGradient(const double *d_x, double *d_f, double *d_gradf) 23: void AmberPotential::computeEnergyAndGradient(const double *d_x, double *d_f, double *d_gradf)
 25: { 24: {
 26:         double testEnergy; 25:         double testEnergy;
 27:  26: 
 28:         // Copy coordinates to correct location in device memory.  27:         // Copy coordinates to correct location in device memory. 
 29:         gminoptim_copy_crd(d_x); 28:         gminoptim_copy_crd(d_x);
 30:         CudaCheckError(); 29:         CudaCheckError();


r29335/cost_function.cu 2015-11-17 23:32:28.952088350 +0000 r29334/cost_function.cu 2015-11-17 23:32:31.260119305 +0000
  4:  *  4:  *
  5:  **/  5:  **/
  6:   6: 
  7: #include<iomanip>  7: #include<iomanip>
  8:   8: 
  9: #include "cost_function.h"  9: #include "cost_function.h"
 10:  10: 
 11: CostFunction::CostFunction(Printing &debugPrinting, Timer &timer_potential, Cublas &cublas, size_t numDimensions, int nDegFreedom,  11: CostFunction::CostFunction(Printing &debugPrinting, Timer &timer_potential, Cublas &cublas, size_t numDimensions, int nDegFreedom, 
 12:                 int nRigidBody, int rigidMaxSite, int *nRigidSitesPerBody, int *rigidGroups, double *sitesRigidBody,  12:                 int nRigidBody, int rigidMaxSite, int *nRigidSitesPerBody, int *rigidGroups, double *sitesRigidBody, 
 13:                 int *rigidSingles, double *rigidInverse, double *coords, int nSecDiag, bool isAtomisticNotRigid,  13:                 int *rigidSingles, double *rigidInverse, double *coords, int nSecDiag, bool isAtomisticNotRigid, 
 14:                 double aaConvThreshold, double coldFusionLim, bool shouldFreeze, bool *isAtomFrozen, int nFreeze,  14:                 double aaConvThreshold, double coldFusionLim, bool shouldFreeze, bool *isAtomFrozen, int nFreeze)
 15:                 bool isAaConvergence) 
 16:         : m_timer_potential(timer_potential) 15:         : m_timer_potential(timer_potential)
 17:         , m_numDimensions(numDimensions) 16:         , m_numDimensions(numDimensions)
 18:         , m_nDegFreedom(nDegFreedom) 17:         , m_nDegFreedom(nDegFreedom)
 19:         , m_nRigidBody(nRigidBody) 18:         , m_nRigidBody(nRigidBody)
 20:         , m_rigidMaxSite(rigidMaxSite) 19:         , m_rigidMaxSite(rigidMaxSite)
 21:         , m_nRigidSitesPerBody(nRigidSitesPerBody) 20:         , m_nRigidSitesPerBody(nRigidSitesPerBody)
 22:         , m_rigidGroups(rigidGroups) 21:         , m_rigidGroups(rigidGroups)
 23:         , m_sitesRigidBody(sitesRigidBody) 22:         , m_sitesRigidBody(sitesRigidBody)
 24:         , m_rigidSingles(rigidSingles) 23:         , m_rigidSingles(rigidSingles)
 25:         , m_rigidInverse(rigidInverse) 24:         , m_rigidInverse(rigidInverse)
 38:         , m_nSecDiag(nSecDiag) 37:         , m_nSecDiag(nSecDiag)
 39:         , m_isAtomisticNotRigid(isAtomisticNotRigid) 38:         , m_isAtomisticNotRigid(isAtomisticNotRigid)
 40:         , m_aaConvThreshold(aaConvThreshold) 39:         , m_aaConvThreshold(aaConvThreshold)
 41:         , m_nCalls(0) 40:         , m_nCalls(0)
 42:         , m_coldFusionLim(coldFusionLim) 41:         , m_coldFusionLim(coldFusionLim)
 43:         , m_shouldFreeze(shouldFreeze) 42:         , m_shouldFreeze(shouldFreeze)
 44:         , m_isAtomFrozen(isAtomFrozen) 43:         , m_isAtomFrozen(isAtomFrozen)
 45:         , m_nFreeze(nFreeze) 44:         , m_nFreeze(nFreeze)
 46:         , m_debugPrinting(debugPrinting) 45:         , m_debugPrinting(debugPrinting)
 47:         , m_cublas(cublas) 46:         , m_cublas(cublas)
 48:         , m_isBfgsts(false) 47:           , m_isBfgsts(false)
 49:           , m_isAaConvergence(isAaConvergence) 
 50: { 48: {
 51:         double *zerosx; 49:         double *zerosx;
 52:         double *zerosy; 50:         double *zerosy;
 53:         double *zerosz; 51:         double *zerosz;
 54:  52: 
 55:         zerosx = new double[numDimensions]; 53:         zerosx = new double[numDimensions];
 56:         zerosy = new double[numDimensions]; 54:         zerosy = new double[numDimensions];
 57:         zerosz = new double[numDimensions]; 55:         zerosz = new double[numDimensions];
 58:  56: 
 59:         CudaSafeCall( cudaMalloc(&m_d_zerosx, m_numDimensions * sizeof(double)) ); 57:         CudaSafeCall( cudaMalloc(&m_d_zerosx, m_numDimensions * sizeof(double)) );
475: }473: }
476: 474: 
477: 475: 
478: 476: 
479: void CostFunction::calculateRms(const double *d_gradf, double *outRms)477: void CostFunction::calculateRms(const double *d_gradf, double *outRms)
480: {478: {
481:         double gkNormSquared;479:         double gkNormSquared;
482:         m_cublas.dispatchDot(m_numDimensions, &gkNormSquared, d_gradf, d_gradf, false); // gkNormSquared = gradf Dot gradf480:         m_cublas.dispatchDot(m_numDimensions, &gkNormSquared, d_gradf, d_gradf, false); // gkNormSquared = gradf Dot gradf
483:         if (!m_isAtomisticNotRigid) {481:         if (!m_isAtomisticNotRigid) {
484:                 *outRms = fmax(sqrt(gkNormSquared/m_nDegFreedom), 1.0e-100);482:                 *outRms = fmax(sqrt(gkNormSquared/m_nDegFreedom), 1.0e-100);
485:                 if (m_isAaConvergence && (*outRms < m_aaConvThreshold) && !m_isBfgsts) {483:                 if ((*outRms < m_aaConvThreshold) && !m_isBfgsts) {
486:                         aaConvergence(m_d_gkAtoms, outRms);484:                         aaConvergence(m_d_gkAtoms, outRms);
487:                         *outRms = fmax(sqrt(*outRms/m_numDimensions), 1.0e-100);485:                         *outRms = fmax(sqrt(*outRms/m_numDimensions), 1.0e-100);
488:                 }486:                 }
489:         }487:         }
490:         else {488:         else {
491:                 *outRms = fmax(sqrt(gkNormSquared/m_numDimensions), 1.0e-100);489:                 *outRms = fmax(sqrt(gkNormSquared/m_numDimensions), 1.0e-100);
492:         }490:         }
493: }491: }
494: 492: 
495: 493: 


r29335/cost_function.h 2015-11-17 23:32:29.136090818 +0000 r29334/cost_function.h 2015-11-17 23:32:31.448121829 +0000
 23:  23: 
 24: // GPU based cost functions can directly inherit from this class 24: // GPU based cost functions can directly inherit from this class
 25: // and implement computeEnergyAndGradient(), the passed pointers are supposed 25: // and implement computeEnergyAndGradient(), the passed pointers are supposed
 26: // to reside in device memory. 26: // to reside in device memory.
 27: class CostFunction 27: class CostFunction
 28: { 28: {
 29:         public: 29:         public:
 30:                 CostFunction(Printing &debugPrinting, Timer &timer_potential, Cublas &cublas, size_t numDimensions, int nDegFreedom,  30:                 CostFunction(Printing &debugPrinting, Timer &timer_potential, Cublas &cublas, size_t numDimensions, int nDegFreedom, 
 31:                                 int nRigidBody, int rigidMaxSite, int *nRigidSitesPerBody, int *rigidGroups, double *sitesRigidBody,  31:                                 int nRigidBody, int rigidMaxSite, int *nRigidSitesPerBody, int *rigidGroups, double *sitesRigidBody, 
 32:                                 int *rigidSingles, double *rigidInverse, double *coords, int nSecDiag, bool isAtomisticNotRigid,  32:                                 int *rigidSingles, double *rigidInverse, double *coords, int nSecDiag, bool isAtomisticNotRigid, 
 33:                                 double aaConvThreshold, double coldFusionLim, bool shouldFreeze, bool *isAtomFrozen, int nFreeze,  33:                                 double aaConvThreshold, double coldFusionLim, bool shouldFreeze, bool *isAtomFrozen, int nFreeze);
 34:                                 bool isAaConvergence); 
 35:  34: 
 36:                 ~CostFunction(); 35:                 ~CostFunction();
 37:  36: 
 38:                 // Calculates secdiag if R-R minimization and calls rigid body transformations and computeEnergyAndGradient.  37:                 // Calculates secdiag if R-R minimization and calls rigid body transformations and computeEnergyAndGradient. 
 39:                 void basePotential(double *d_x, double *d_f, double *d_gradf); 38:                 void basePotential(double *d_x, double *d_f, double *d_gradf);
 40:  39: 
 41:                 // Implement this method computing both function value d_f 40:                 // Implement this method computing both function value d_f
 42:                 // and gradient d_gradf of your cost function at point d_x. 41:                 // and gradient d_gradf of your cost function at point d_x.
 43:                 virtual void computeEnergyAndGradient(const double *d_x, double *d_f, double *d_gradf) = 0; 42:                 virtual void computeEnergyAndGradient(const double *d_x, double *d_f, double *d_gradf) = 0;
 44:  43: 
 94:                 int           m_nCalls;               // No. of potential calls made during this invocation of the CUDA code. 93:                 int           m_nCalls;               // No. of potential calls made during this invocation of the CUDA code.
 95:  94: 
 96:                 const bool    m_shouldFreeze;         // If true, freeze some specified coordinates. 95:                 const bool    m_shouldFreeze;         // If true, freeze some specified coordinates.
 97:  96: 
 98:                 const bool   *m_isAtomFrozen;         // Logical array specifying frozen atoms. 97:                 const bool   *m_isAtomFrozen;         // Logical array specifying frozen atoms.
 99:  98: 
100:                 bool          m_isBfgsts;             // True if costFunction is being used in a Bfgsts calculation - stops aaConvergence call. 99:                 bool          m_isBfgsts;             // True if costFunction is being used in a Bfgsts calculation - stops aaConvergence call.
101:                 bool          m_isRayleighRitz;       // If true, curvature of PES calculated along direction vec at point coords (R-R min).100:                 bool          m_isRayleighRitz;       // If true, curvature of PES calculated along direction vec at point coords (R-R min).
102: 101: 
103:                 const bool    m_isAtomisticNotRigid;  // If false, use rigid body coordinates.102:                 const bool    m_isAtomisticNotRigid;  // If false, use rigid body coordinates.
104:                 const bool    m_isAaConvergence;      // RBF: if true, use more accurate method of calculating RMS force. 
105: 103: 
106:                 const double *m_sitesRigidBody;       // RBF: coordinates of the rigid body sites.104:                 const double *m_sitesRigidBody;       // RBF: coordinates of the rigid body sites.
107:                 const double *m_rigidInverse;         // RBF: inverse eigenvalues of the unweighted tensor of gyration. 105:                 const double *m_rigidInverse;         // RBF: IINVERSE from genrigid, used in aaConvergence subroutine.
108: 106: 
109:                 const int     m_nDegFreedom;          // RBF: no. of degrees of freedom.107:                 const int     m_nDegFreedom;          // RBF: no. of degrees of freedom.
110:                 const int     m_nRigidBody;           // RBF: no. of rigid bodies108:                 const int     m_nRigidBody;           // RBF: no. of rigid bodies
111:                 const int     m_rigidMaxSite;         // RBF: max. no. of sites in a rigid body.109:                 const int     m_rigidMaxSite;         // RBF: max. no. of sites in a rigid body.
112: 110: 
113:                 const int    *m_nRigidSitesPerBody;   // RBF: no. of rigid body sites.111:                 const int    *m_nRigidSitesPerBody;   // RBF: no. of rigid body sites.
114:                 const int    *m_rigidGroups;          // RBF: list of atoms in rigid bodies.112:                 const int    *m_rigidGroups;          // RBF: list of atoms in rigid bodies.
115:                 const int    *m_rigidSingles;         // RBF: list of atoms not in rigid bodies.113:                 const int    *m_rigidSingles;         // RBF: list of atoms not in rigid bodies.
116: 114: 
117: 115: 


r29335/genrigid.f90 2015-11-17 23:32:30.468108685 +0000 r29334/genrigid.f90 2015-11-17 23:32:32.772139584 +0000
175:      XMASS = XMASS / MASS175:      XMASS = XMASS / MASS
176:      YMASS = YMASS / MASS176:      YMASS = YMASS / MASS
177:      ZMASS = ZMASS / MASS177:      ZMASS = ZMASS / MASS
178: 178: 
179:      DO J2 = 1, NSITEPERBODY(J1)179:      DO J2 = 1, NSITEPERBODY(J1)
180:         SITESRIGIDBODY(J2,1,J1) = SITESRIGIDBODY(J2,1,J1) - XMASS180:         SITESRIGIDBODY(J2,1,J1) = SITESRIGIDBODY(J2,1,J1) - XMASS
181:         SITESRIGIDBODY(J2,2,J1) = SITESRIGIDBODY(J2,2,J1) - YMASS181:         SITESRIGIDBODY(J2,2,J1) = SITESRIGIDBODY(J2,2,J1) - YMASS
182:         SITESRIGIDBODY(J2,3,J1) = SITESRIGIDBODY(J2,3,J1) - ZMASS182:         SITESRIGIDBODY(J2,3,J1) = SITESRIGIDBODY(J2,3,J1) - ZMASS
183:      ENDDO183:      ENDDO
184:   ENDDO184:   ENDDO
185:  
186:   DO J1 = 1, NRIGIDBODY 
187:      IINVERSE(J1,:,:) = 0.0D0 
188:   END DO 
189:  
190:   IF (AACONVERGENCET .EQV. .TRUE.) THEN185:   IF (AACONVERGENCET .EQV. .TRUE.) THEN
191:      DO J1 = 1, NRIGIDBODY186:      DO J1 = 1, NRIGIDBODY
192:         KBLOCK(:,:) = 0.0D0187:         KBLOCK(:,:) = 0.0D0
193:         DO J2 = 1, NSITEPERBODY(J1)188:         DO J2 = 1, NSITEPERBODY(J1)
194:            DR(:)  = SITESRIGIDBODY(J2,:,J1)189:            DR(:)  = SITESRIGIDBODY(J2,:,J1)
195:            DO I = 1, 3190:            DO I = 1, 3
196:               ! KBLOCK is the unweighted tensor of gyration191:               ! KBLOCK is the unweighted tensor of gyration
197:               KBLOCK(I,I) = KBLOCK(I,I) + (DR(1)*DR(1) + DR(2)*DR(2) + DR(3)*DR(3))192:               KBLOCK(I,I) = KBLOCK(I,I) + (DR(1)*DR(1) + DR(2)*DR(2) + DR(3)*DR(3))
198:               DO J = 1, 3    ! could have been J = 1, I; KBLOCK is a symmetric matrix193:               DO J = 1, 3    ! could have been J = 1, I; KBLOCK is a symmetric matrix
199:                  KBLOCK(I,J) = KBLOCK(I,J) - DR(I)*DR(J)194:                  KBLOCK(I,J) = KBLOCK(I,J) - DR(I)*DR(J)
204:         CALL RBDET(KBLOCK, DET)199:         CALL RBDET(KBLOCK, DET)
205:         IF (DET < 0.0D0) THEN200:         IF (DET < 0.0D0) THEN
206:            KBLOCK(:,3) = -KBLOCK(:,3)201:            KBLOCK(:,3) = -KBLOCK(:,3)
207:            CALL RBDET(KBLOCK, DET)202:            CALL RBDET(KBLOCK, DET)
208:            IF (DET < 0.0D0) THEN203:            IF (DET < 0.0D0) THEN
209:               PRINT *, "GENRIGID> BAD ALIGNMENT", J1204:               PRINT *, "GENRIGID> BAD ALIGNMENT", J1
210:               STOP205:               STOP
211:            ENDIF206:            ENDIF
212:         ENDIF207:         ENDIF
213:         KBLOCK = TRANSPOSE(KBLOCK)208:         KBLOCK = TRANSPOSE(KBLOCK)
 209:         IINVERSE(J1,:,:) = 0.0D0
214: !        PRINT *, KBEGNV210: !        PRINT *, KBEGNV
215:         IINVERSE(J1,1,1) = 1.0D0/KBEGNV(1)211:         IINVERSE(J1,1,1) = 1.0D0/KBEGNV(1)
216:         IINVERSE(J1,2,2) = 1.0D0/KBEGNV(2)212:         IINVERSE(J1,2,2) = 1.0D0/KBEGNV(2)
217:         IINVERSE(J1,3,3) = 1.0D0/KBEGNV(3)213:         IINVERSE(J1,3,3) = 1.0D0/KBEGNV(3)
218:         DO J2 = 1, NSITEPERBODY(J1)214:         DO J2 = 1, NSITEPERBODY(J1)
219:            SITESRIGIDBODY(J2,:,J1) = MATMUL(KBLOCK,SITESRIGIDBODY(J2,:,J1))215:            SITESRIGIDBODY(J2,:,J1) = MATMUL(KBLOCK,SITESRIGIDBODY(J2,:,J1))
220:         ENDDO216:         ENDDO
221:      ENDDO217:      ENDDO
222:   ENDIF218:   ENDIF
223: !  PRINT *, SITESRIGIDBODY(1,:,1)219: !  PRINT *, SITESRIGIDBODY(1,:,1)
786:               GR(J2-2:J2) = matmul(transpose(mlattice), GR(J2-2:J2))782:               GR(J2-2:J2) = matmul(transpose(mlattice), GR(J2-2:J2))
787:           ENDDO783:           ENDDO
788:       ENDIF784:       ENDIF
789:       ! copy lattice gradient785:       ! copy lattice gradient
790:       GR(DEGFREEDOMS-5:DEGFREEDOMS) = G(3*NATOMS-5:3*NATOMS)786:       GR(DEGFREEDOMS-5:DEGFREEDOMS) = G(3*NATOMS-5:3*NATOMS)
791:   ENDIF787:   ENDIF
792: 788: 
793: END SUBROUTINE TRANSFORMGRAD789: END SUBROUTINE TRANSFORMGRAD
794: 790: 
795: SUBROUTINE AACONVERGENCE (G, XR, GR, RMS)791: SUBROUTINE AACONVERGENCE (G, XR, GR, RMS)
796: ! Atomistic gradient, rigid coords, rigid gradient 
797: 792: 
798:   USE COMMONS, ONLY: NATOMS793:   USE COMMONS, ONLY: NATOMS
799:   IMPLICIT NONE794:   IMPLICIT NONE
800: 795: 
801:   INTEGER          :: J1, J2, J9796:   INTEGER          :: J1, J2, J9
802:   DOUBLE PRECISION :: G(3*NATOMS), XR(DEGFREEDOMS), GR(DEGFREEDOMS)797:   DOUBLE PRECISION :: G(3*NATOMS), XR(DEGFREEDOMS), GR(DEGFREEDOMS)
803:   DOUBLE PRECISION :: PI(3)798:   DOUBLE PRECISION :: PI(3)
804:   DOUBLE PRECISION :: RMI(3,3), DRMI1(3,3), DRMI2(3,3), DRMI3(3,3)799:   DOUBLE PRECISION :: RMI(3,3), DRMI1(3,3), DRMI2(3,3), DRMI3(3,3)
805:   DOUBLE PRECISION :: TORQUE(3)800:   DOUBLE PRECISION :: TORQUE(3)
806:   DOUBLE PRECISION :: RMI0(3,3), DRMI10(3,3), DRMI20(3,3), DRMI30(3,3)801:   DOUBLE PRECISION :: RMI0(3,3), DRMI10(3,3), DRMI20(3,3), DRMI30(3,3)


r29335/lj_potential.cu 2015-11-17 23:32:29.888100904 +0000 r29334/lj_potential.cu 2015-11-17 23:32:32.200131912 +0000
115:                 }115:                 }
116:         }116:         }
117: }117: }
118: 118: 
119: 119: 
120: 120: 
121: LjPotential::LjPotential(Printing &debugPrinting, Timer &timer_potential, Cublas &cublas, size_t numDimensions, 121: LjPotential::LjPotential(Printing &debugPrinting, Timer &timer_potential, Cublas &cublas, size_t numDimensions, 
122:                 int nDegFreedom, int nRigidBody, int rigidMaxSite, int *nRigidSitesPerBody, 122:                 int nDegFreedom, int nRigidBody, int rigidMaxSite, int *nRigidSitesPerBody, 
123:                 int *rigidGroups, double *sitesRigidBody, int *rigidSingles, double *rigidInverse, 123:                 int *rigidGroups, double *sitesRigidBody, int *rigidSingles, double *rigidInverse, 
124:                 double *coords, int nSecDiag, bool isAtomisticNotRigid, double aaConvThreshold, 124:                 double *coords, int nSecDiag, bool isAtomisticNotRigid, double aaConvThreshold, 
125:                 double coldFusionLim, bool shouldFreeze, bool *isAtomFrozen, int nFreeze, bool isAaConvergence)125:                 double coldFusionLim, bool shouldFreeze, bool *isAtomFrozen, int nFreeze)
126: : CostFunction(debugPrinting, timer_potential, cublas, numDimensions, nDegFreedom, nRigidBody, rigidMaxSite, 126: : CostFunction(debugPrinting, timer_potential, cublas, numDimensions, nDegFreedom, nRigidBody, rigidMaxSite, 
127:                 nRigidSitesPerBody, rigidGroups, sitesRigidBody, rigidSingles, rigidInverse, coords, 127:                 nRigidSitesPerBody, rigidGroups, sitesRigidBody, rigidSingles, rigidInverse, coords, 
128:                 nSecDiag, isAtomisticNotRigid, aaConvThreshold, coldFusionLim, shouldFreeze, isAtomFrozen, 128:                 nSecDiag, isAtomisticNotRigid, aaConvThreshold, coldFusionLim, shouldFreeze, isAtomFrozen, 
129:                 nFreeze, isAaConvergence)129:                 nFreeze)
130: {130: {
131:         // Copy 3*natoms to GPU131:         // Copy 3*natoms to GPU
132:         CudaSafeCall( cudaMemcpyToSymbol(gpu_lj::m_d_numDimensions, &m_numDimensions, sizeof(size_t)) );132:         CudaSafeCall( cudaMemcpyToSymbol(gpu_lj::m_d_numDimensions, &m_numDimensions, sizeof(size_t)) );
133: }133: }
134: 134: 
135: 135: 
136: 136: 
137: void LjPotential::computeEnergyAndGradient(const double *d_x, double *d_f, double *d_gradf)137: void LjPotential::computeEnergyAndGradient(const double *d_x, double *d_f, double *d_gradf)
138: {138: {
139:         dim3 blockDim;139:         dim3 blockDim;


r29335/modcudabfgsts.f90 2015-11-17 23:32:30.660111260 +0000 r29334/modcudabfgsts.f90 2015-11-17 23:32:32.972142265 +0000
  2:   2: 
  3: USE COMMONS, ONLY : NATOMS, DEBUG, NOPT, STPMAX, REDOPATH, IVEC  3: USE COMMONS, ONLY : NATOMS, DEBUG, NOPT, STPMAX, REDOPATH, IVEC
  4:   4: 
  5: USE KEY, ONLY : CUDAPOT, GMAX, CONVU, CONVR, MINMAX, MXSTP, MAXXBFGS, XMAXERISE, CUDATIMET, CFUSIONT, COLDFUSIONLIMIT, XDGUESS, &   5: USE KEY, ONLY : CUDAPOT, GMAX, CONVU, CONVR, MINMAX, MXSTP, MAXXBFGS, XMAXERISE, CUDATIMET, CFUSIONT, COLDFUSIONLIMIT, XDGUESS, & 
  6:                 XMUPDATE, HINDEX, MASST, SHIFTED, CHECKINDEX, REVERSEUPHILLT, GRADSQ, FREEZE, READV, DUMPV, FIXD, EIGENONLY, &   6:                 XMUPDATE, HINDEX, MASST, SHIFTED, CHECKINDEX, REVERSEUPHILLT, GRADSQ, FREEZE, READV, DUMPV, FIXD, EIGENONLY, & 
  7:                 NSECDIAG, EVPC, CEIG, NEVS, CHECKOVERLAPT, CHECKNEGATIVET, REOPT, BFGSSTEP, PUSHCUT, PUSHOFF, MAXMAX, TRAD, &   7:                 NSECDIAG, EVPC, CEIG, NEVS, CHECKOVERLAPT, CHECKNEGATIVET, REOPT, BFGSSTEP, PUSHCUT, PUSHOFF, MAXMAX, TRAD, & 
  8:                 NBFGSMAX1, NBFGSMAX2, BFGSTSTOL, REPELTST, MUPDATE, MAXBFGS, MAXERISE, DGUESS, NOIT, VARIABLES, NOHESS, FROZEN, &   8:                 NBFGSMAX1, NBFGSMAX2, BFGSTSTOL, REPELTST, MUPDATE, MAXBFGS, MAXERISE, DGUESS, NOIT, VARIABLES, NOHESS, FROZEN, & 
  9:                 NFREEZE, PV, FIXAFTER, CPMD, PRINTPTS, TWOENDS, DUMPMAG, NSTEPMIN, AMBER12T  9:                 NFREEZE, PV, FIXAFTER, CPMD, PRINTPTS, TWOENDS, DUMPMAG, NSTEPMIN, AMBER12T
 10:  10: 
 11: USE GENRIGID, ONLY : RIGIDINIT, ATOMRIGIDCOORDT, DEGFREEDOMS, NRIGIDBODY, NSITEPERBODY, RIGIDGROUPS, MAXSITE, SITESRIGIDBODY, & 11: USE GENRIGID, ONLY : RIGIDINIT, ATOMRIGIDCOORDT, DEGFREEDOMS, NRIGIDBODY, NSITEPERBODY, RIGIDGROUPS, MAXSITE, SITESRIGIDBODY, &
 12:                      RIGIDSINGLES, IINVERSE, AACONVERGENCET 12:                      RIGIDSINGLES, IINVERSE
 13:  13: 
 14: USE ZWK, ONLY : NUP, ZWORK 14: USE ZWK, ONLY : NUP, ZWORK
 15:  15: 
 16: USE MODNEB, ONLY : NEWCONNECTT, NEWNEBT 16: USE MODNEB, ONLY : NEWCONNECTT, NEWNEBT
 17:  17: 
 18: USE INTCOMMONS, ONLY : BONDSFROMFILE 18: USE INTCOMMONS, ONLY : BONDSFROMFILE
 19:  19: 
 20: USE INTERNALS_WRAPPER, ONLY : INTWRAP_USEINTERNALS 20: USE INTERNALS_WRAPPER, ONLY : INTWRAP_USEINTERNALS
 21:  21: 
 22: USE MODAMBER9, ONLY : CHECKCISTRANSALWAYS, CHECKCISTRANSALWAYSDNA, CHECKCISTRANSALWAYSRNA 22: USE MODAMBER9, ONLY : CHECKCISTRANSALWAYS, CHECKCISTRANSALWAYSDNA, CHECKCISTRANSALWAYSRNA
 25:  25: 
 26: IMPLICIT NONE 26: IMPLICIT NONE
 27:  27: 
 28: INTERFACE 28: INTERFACE
 29:     SUBROUTINE CUDA_BFGSTS(C_NATOMS, C_COORDS, C_CEIG, C_MFLAG, C_ENERGY, C_NEVS, ITMAX, C_ITER, C_MAXXBFGS, C_XMAXERISE, C_RMS, & 29:     SUBROUTINE CUDA_BFGSTS(C_NATOMS, C_COORDS, C_CEIG, C_MFLAG, C_ENERGY, C_NEVS, ITMAX, C_ITER, C_MAXXBFGS, C_XMAXERISE, C_RMS, &
 30:                           C_CUDAPOT, C_DEBUG, C_CUDATIMET, NCALLS, C_CFUSIONT, C_COLDFUSIONLIMIT, C_XDGUESS, C_XMUPDATE, & 30:                           C_CUDAPOT, C_DEBUG, C_CUDATIMET, NCALLS, C_CFUSIONT, C_COLDFUSIONLIMIT, C_XDGUESS, C_XMUPDATE, &
 31:                           C_EVALMIN, C_VECS, C_ATOMRIGIDCOORDT, C_DEGFREEDOMS, C_NRIGIDBODY, C_NSITEPERBODY, C_RIGIDGROUPS, & 31:                           C_EVALMIN, C_VECS, C_ATOMRIGIDCOORDT, C_DEGFREEDOMS, C_NRIGIDBODY, C_NSITEPERBODY, C_RIGIDGROUPS, &
 32:                           C_MAXSITE, C_SITESRIGIDBODY, C_RIGIDSINGLES, C_IINVERSE, C_NSECDIAG, C_EVPC, & 32:                           C_MAXSITE, C_SITESRIGIDBODY, C_RIGIDSINGLES, C_IINVERSE, C_NSECDIAG, C_EVPC, &
 33:                           C_PUSHCUT, C_PUSHOFF, C_STPMAX, C_MAXMAX, C_MINMAX, C_TRAD, C_NBFGSMAX1, C_NBFGSMAX2, C_BFGSTSTOL, & 33:                           C_PUSHCUT, C_PUSHOFF, C_STPMAX, C_MAXMAX, C_MINMAX, C_TRAD, C_NBFGSMAX1, C_NBFGSMAX2, C_BFGSTSTOL, &
 34:                           C_MUPDATE, C_GMAX, C_MAXBFGS, C_MAXERISE, C_DGUESS, C_CONVU, C_FREEZE, C_FROZEN, &  34:                           C_MUPDATE, C_GMAX, C_MAXBFGS, C_MAXERISE, C_DGUESS, C_CONVU, C_FREEZE, C_FROZEN, & 
 35:                           C_NFREEZE, POTENTIALTIME, C_AACONVERGENCET)BIND(C,NAME="setup_bfgsts") 35:                           C_NFREEZE, POTENTIALTIME)BIND(C,NAME="setup_bfgsts")
 36:  36: 
 37:         IMPORT :: C_INT, C_DOUBLE, C_BOOL, C_CHAR 37:         IMPORT :: C_INT, C_DOUBLE, C_BOOL, C_CHAR
 38:  38: 
 39:         INTEGER(KIND=C_INT), INTENT(IN) :: C_NATOMS, & ! No. of atoms 39:         INTEGER(KIND=C_INT), INTENT(IN) :: C_NATOMS, & ! No. of atoms
 40:                                            ITMAX, & ! Max. no. of BFGSTS iterations allowed 40:                                            ITMAX, & ! Max. no. of BFGSTS iterations allowed
 41:                                            C_DEGFREEDOMS, & ! Rigid Body Framework (RBF): no. of degrees of freedom 41:                                            C_DEGFREEDOMS, & ! Rigid Body Framework (RBF): no. of degrees of freedom
 42:                                            C_NRIGIDBODY, & ! RBF: no. of rigid bodies 42:                                            C_NRIGIDBODY, & ! RBF: no. of rigid bodies
 43:                                            C_MAXSITE, & ! RBF: max. no. of sites in a rigid body 43:                                            C_MAXSITE, & ! RBF: max. no. of sites in a rigid body
 44:                                            C_XMUPDATE, & ! History size for Rayleigh-Ritz (R-R) LBFGS minimization 44:                                            C_XMUPDATE, & ! History size for Rayleigh-Ritz (R-R) LBFGS minimization
 45:                                            C_NSECDIAG, & ! Method used to approximate eigenvalue in R-R LBFGS 45:                                            C_NSECDIAG, & ! Method used to approximate eigenvalue in R-R LBFGS
 72:                                            C_TRAD, & ! Trust radius for adjusting max. step along eigenvector 72:                                            C_TRAD, & ! Trust radius for adjusting max. step along eigenvector
 73:                                            C_BFGSTSTOL, & ! Tolerance for eigenvector overlap (no. tangent space steps small->large) 73:                                            C_BFGSTSTOL, & ! Tolerance for eigenvector overlap (no. tangent space steps small->large)
 74:                                            C_GMAX, & ! Convergence tolerance for RMS force for restricted LBFGS minimization 74:                                            C_GMAX, & ! Convergence tolerance for RMS force for restricted LBFGS minimization
 75:                                            C_MAXBFGS, & ! Max. step size allowed for restricted LBFGS 75:                                            C_MAXBFGS, & ! Max. step size allowed for restricted LBFGS
 76:                                            C_MAXERISE, & ! Max. energy rise allowed for restricted LBFGS 76:                                            C_MAXERISE, & ! Max. energy rise allowed for restricted LBFGS
 77:                                            C_DGUESS, & ! Initial guess for restricted LBFGS inverse Hessian diagonal elements 77:                                            C_DGUESS, & ! Initial guess for restricted LBFGS inverse Hessian diagonal elements
 78:                                            C_CONVU ! Can only converge if eigenvector following step length magnitude falls below this value 78:                                            C_CONVU ! Can only converge if eigenvector following step length magnitude falls below this value
 79:  79: 
 80:         REAL(KIND=C_DOUBLE), DIMENSION(C_MAXSITE*3*C_NRIGIDBODY), INTENT(IN) :: C_SITESRIGIDBODY ! RBF: coordinates of the rigid body sites 80:         REAL(KIND=C_DOUBLE), DIMENSION(C_MAXSITE*3*C_NRIGIDBODY), INTENT(IN) :: C_SITESRIGIDBODY ! RBF: coordinates of the rigid body sites
 81:  81: 
 82:         REAL(KIND=C_DOUBLE), DIMENSION(C_NRIGIDBODY*3*3), INTENT(IN) :: C_IINVERSE ! RBF: inverse eigenvalues of the unweighted tensor of gyration 82:         REAL(KIND=C_DOUBLE), DIMENSION(C_NRIGIDBODY*3*3), INTENT(IN) :: C_IINVERSE ! RBF: from genrigid, used in aaconvergence subroutine
 83:  83: 
 84:         REAL(KIND=C_DOUBLE), DIMENSION(3*C_NATOMS), INTENT(INOUT) :: C_COORDS, & ! Coordinates 84:         REAL(KIND=C_DOUBLE), DIMENSION(3*C_NATOMS), INTENT(INOUT) :: C_COORDS, & ! Coordinates
 85:                                                                      C_VECS ! Lowest eigenvector 85:                                                                      C_VECS ! Lowest eigenvector
 86:  86: 
 87:         REAL(KIND=C_DOUBLE), INTENT(OUT) :: C_ENERGY, & ! Energy at coordinates C_COORDS 87:         REAL(KIND=C_DOUBLE), INTENT(OUT) :: C_ENERGY, & ! Energy at coordinates C_COORDS
 88:                                             C_RMS, & ! RMS force 88:                                             C_RMS, & ! RMS force
 89:                                             C_EVALMIN, & ! Smallest eigenvalue 89:                                             C_EVALMIN, & ! Smallest eigenvalue
 90:                                             POTENTIALTIME ! Time taken in calculating potential 90:                                             POTENTIALTIME ! Time taken in calculating potential
 91:  91: 
 92:         LOGICAL(KIND=C_BOOL), INTENT(IN) :: C_DEBUG, & ! If true, print debug info. 92:         LOGICAL(KIND=C_BOOL), INTENT(IN) :: C_DEBUG, & ! If true, print debug info.
 93:                                             C_CUDATIMET, & ! If true, print timing info. 93:                                             C_CUDATIMET, & ! If true, print timing info.
 94:                                             C_ATOMRIGIDCOORDT, & ! If false, use rigid body coordinates 94:                                             C_ATOMRIGIDCOORDT, & ! If false, use rigid body coordinates
 95:                                             C_FREEZE, & ! If true, freeze some specified coordinates 95:                                             C_FREEZE ! If true, freeze some specified coordinates
 96:                                             C_AACONVERGENCET ! If true, use more accurate method of calculating rigid RMS force 
 97:  96: 
 98:         LOGICAL(KIND=C_BOOL), DIMENSION(C_NATOMS), INTENT(IN) :: C_FROZEN ! Logical array specifying frozen atoms 97:         LOGICAL(KIND=C_BOOL), DIMENSION(C_NATOMS), INTENT(IN) :: C_FROZEN ! Logical array specifying frozen atoms
 99:  98: 
100:         LOGICAL(KIND=C_BOOL), INTENT(OUT) :: C_MFLAG, & ! True if converged to a transition state 99:         LOGICAL(KIND=C_BOOL), INTENT(OUT) :: C_MFLAG, & ! True if converged to a transition state
101:                                              C_CFUSIONT ! Set to true during BFGSTS if cold fusion diagnosed100:                                              C_CFUSIONT ! Set to true during BFGSTS if cold fusion diagnosed
102: 101: 
103:         CHARACTER(LEN=1, KIND=C_CHAR), INTENT(IN) :: C_CUDAPOT ! Character specifying the CUDA potential to be used102:         CHARACTER(LEN=1, KIND=C_CHAR), INTENT(IN) :: C_CUDAPOT ! Character specifying the CUDA potential to be used
104: 103: 
105:     END SUBROUTINE CUDA_BFGSTS104:     END SUBROUTINE CUDA_BFGSTS
106: END INTERFACE105: END INTERFACE
116:         INTEGER(KIND=C_INT), DIMENSION(MAXSITE*NRIGIDBODY) :: C_RIGIDGROUPS115:         INTEGER(KIND=C_INT), DIMENSION(MAXSITE*NRIGIDBODY) :: C_RIGIDGROUPS
117:         INTEGER(KIND=C_INT), DIMENSION(DEGFREEDOMS/3 - 2*NRIGIDBODY) :: C_RIGIDSINGLES116:         INTEGER(KIND=C_INT), DIMENSION(DEGFREEDOMS/3 - 2*NRIGIDBODY) :: C_RIGIDSINGLES
118: 117: 
119:         REAL(KIND=C_DOUBLE) :: C_CEIG, C_ENERGY, C_RMS, C_XDGUESS, C_EVALMIN, C_MAXXBFGS, C_XMAXERISE, C_COLDFUSIONLIMIT, &118:         REAL(KIND=C_DOUBLE) :: C_CEIG, C_ENERGY, C_RMS, C_XDGUESS, C_EVALMIN, C_MAXXBFGS, C_XMAXERISE, C_COLDFUSIONLIMIT, &
120:                                C_EVPC, C_PUSHCUT, C_PUSHOFF, C_STPMAX, C_MAXMAX, C_MINMAX, C_TRAD, C_BFGSTSTOL, C_GMAX, &119:                                C_EVPC, C_PUSHCUT, C_PUSHOFF, C_STPMAX, C_MAXMAX, C_MINMAX, C_TRAD, C_BFGSTSTOL, C_GMAX, &
121:                                C_MAXBFGS, C_MAXERISE, C_DGUESS, C_CONVU, POTENTIALTIME120:                                C_MAXBFGS, C_MAXERISE, C_DGUESS, C_CONVU, POTENTIALTIME
122:         REAL(KIND=C_DOUBLE), DIMENSION(MAXSITE*3*NRIGIDBODY) :: C_SITESRIGIDBODY 121:         REAL(KIND=C_DOUBLE), DIMENSION(MAXSITE*3*NRIGIDBODY) :: C_SITESRIGIDBODY 
123:         REAL(KIND=C_DOUBLE), DIMENSION(NRIGIDBODY*3*3) :: C_IINVERSE122:         REAL(KIND=C_DOUBLE), DIMENSION(NRIGIDBODY*3*3) :: C_IINVERSE
124:         REAL(KIND=C_DOUBLE), DIMENSION(3*NATOMS) :: C_COORDS, C_VECS123:         REAL(KIND=C_DOUBLE), DIMENSION(3*NATOMS) :: C_COORDS, C_VECS
125: 124: 
126:         LOGICAL(KIND=C_BOOL) :: C_MFLAG, C_DEBUG, C_CUDATIMET, C_CFUSIONT, C_ATOMRIGIDCOORDT, C_FREEZE, C_AACONVERGENCET125:         LOGICAL(KIND=C_BOOL) :: C_MFLAG, C_DEBUG, C_CUDATIMET, C_CFUSIONT, C_ATOMRIGIDCOORDT, C_FREEZE
127:         LOGICAL(KIND=C_BOOL), DIMENSION(NATOMS) :: C_FROZEN126:         LOGICAL(KIND=C_BOOL), DIMENSION(NATOMS) :: C_FROZEN
128: 127: 
129:         CHARACTER(LEN=1, KIND=C_CHAR) :: C_CUDAPOT128:         CHARACTER(LEN=1, KIND=C_CHAR) :: C_CUDAPOT
130: 129: 
131:         ! Variables passed as *arguments through this wrapper* (not common) with intent out for CUDA_BFGSTS are not passed into it130:         ! Variables passed as *arguments through this wrapper* (not common) with intent out for CUDA_BFGSTS are not passed into it
132:         ! Therefore uninitialised C types are passed in and converted types are copied back after the call131:         ! Therefore uninitialised C types are passed in and converted types are copied back after the call
133: 132: 
134:         INTEGER :: I, J, K, ITER, FCALL, NPCALL, ECALL, SCALL133:         INTEGER :: I, J, K, ITER, FCALL, NPCALL, ECALL, SCALL
135:         DOUBLE PRECISION :: ENERGY, RMS, EVALMIN, FTIME, ETIME, STIME134:         DOUBLE PRECISION :: ENERGY, RMS, EVALMIN, FTIME, ETIME, STIME
136:         DOUBLE PRECISION, DIMENSION(3*NATOMS) :: COORDS, VECS135:         DOUBLE PRECISION, DIMENSION(3*NATOMS) :: COORDS, VECS
277:         C_NBFGSMAX2 = NBFGSMAX2276:         C_NBFGSMAX2 = NBFGSMAX2
278:         C_BFGSTSTOL = BFGSTSTOL277:         C_BFGSTSTOL = BFGSTSTOL
279:         C_MUPDATE = MUPDATE278:         C_MUPDATE = MUPDATE
280:         C_GMAX = GMAX279:         C_GMAX = GMAX
281:         C_MAXBFGS = MAXBFGS280:         C_MAXBFGS = MAXBFGS
282:         C_MAXERISE = MAXERISE281:         C_MAXERISE = MAXERISE
283:         C_DGUESS = DGUESS282:         C_DGUESS = DGUESS
284:         C_CONVU = CONVU283:         C_CONVU = CONVU
285:         C_FREEZE = FREEZE284:         C_FREEZE = FREEZE
286:         C_NFREEZE = NFREEZE285:         C_NFREEZE = NFREEZE
287:         C_AACONVERGENCET = AACONVERGENCET 
288: 286: 
289:         ! 'C_' prefix denotes those variables which have intent out or inout or are copies of those from common blocks/modules287:         ! 'C_' prefix denotes those variables which have intent out or inout or are copies of those from common blocks/modules
290:         CALL CUDA_BFGSTS(C_NATOMS, C_COORDS, C_CEIG, C_MFLAG, C_ENERGY, C_NEVS, ITMAX, C_ITER, C_MAXXBFGS, C_XMAXERISE, C_RMS, &288:         CALL CUDA_BFGSTS(C_NATOMS, C_COORDS, C_CEIG, C_MFLAG, C_ENERGY, C_NEVS, ITMAX, C_ITER, C_MAXXBFGS, C_XMAXERISE, C_RMS, &
291:                         C_CUDAPOT, C_DEBUG, C_CUDATIMET, NCALLS, C_CFUSIONT, C_COLDFUSIONLIMIT, C_XDGUESS, C_XMUPDATE, C_EVALMIN, &289:                         C_CUDAPOT, C_DEBUG, C_CUDATIMET, NCALLS, C_CFUSIONT, C_COLDFUSIONLIMIT, C_XDGUESS, C_XMUPDATE, C_EVALMIN, &
292:                         C_VECS, C_ATOMRIGIDCOORDT, C_DEGFREEDOMS, C_NRIGIDBODY, C_NSITEPERBODY, C_RIGIDGROUPS, C_MAXSITE, &290:                         C_VECS, C_ATOMRIGIDCOORDT, C_DEGFREEDOMS, C_NRIGIDBODY, C_NSITEPERBODY, C_RIGIDGROUPS, C_MAXSITE, &
293:                         C_SITESRIGIDBODY, C_RIGIDSINGLES, C_IINVERSE, C_NSECDIAG, C_EVPC, C_PUSHCUT, C_PUSHOFF, &291:                         C_SITESRIGIDBODY, C_RIGIDSINGLES, C_IINVERSE, C_NSECDIAG, C_EVPC, C_PUSHCUT, C_PUSHOFF, &
294:                         C_STPMAX, C_MAXMAX, C_MINMAX, C_TRAD, C_NBFGSMAX1, C_NBFGSMAX2, C_BFGSTSTOL, C_MUPDATE, C_GMAX, &292:                         C_STPMAX, C_MAXMAX, C_MINMAX, C_TRAD, C_NBFGSMAX1, C_NBFGSMAX2, C_BFGSTSTOL, C_MUPDATE, C_GMAX, &
295:                         C_MAXBFGS, C_MAXERISE, C_DGUESS, C_CONVU, C_FREEZE, C_FROZEN, C_NFREEZE, POTENTIALTIME, C_AACONVERGENCET)293:                         C_MAXBFGS, C_MAXERISE, C_DGUESS, C_CONVU, C_FREEZE, C_FROZEN, C_NFREEZE, POTENTIALTIME)
296: 294: 
297:         ! Make sure C types with intent out or inout are coverted back to Fortran ones295:         ! Make sure C types with intent out or inout are coverted back to Fortran ones
298: 296: 
299:         DO I = 1,3*NATOMS297:         DO I = 1,3*NATOMS
300:             COORDS(I) = DBLE(C_COORDS(I))298:             COORDS(I) = DBLE(C_COORDS(I))
301:         END DO299:         END DO
302: 300: 
303:         DO I = 1,3*NATOMS301:         DO I = 1,3*NATOMS
304:             VECS(I) = DBLE(C_VECS(I))302:             VECS(I) = DBLE(C_VECS(I))
305:         END DO303:         END DO


r29335/modcudalbfgs.f90 2015-11-17 23:32:30.852113832 +0000 r29334/modcudalbfgs.f90 2015-11-17 23:32:33.160144787 +0000
  1: MODULE MODCUDALBFGS  1: MODULE MODCUDALBFGS
  2:   2: 
  3: USE KEY, ONLY : GMAX, CUDATIMET, CUDAPOT, MAXBFGS, MAXERISE, CFUSIONT, COLDFUSIONLIMIT, DGUESS, GRADSQ, FREEZE, REVERSEUPHILLT, &   3: USE KEY, ONLY : GMAX, CUDATIMET, CUDAPOT, MAXBFGS, MAXERISE, CFUSIONT, COLDFUSIONLIMIT, DGUESS, GRADSQ, FREEZE, REVERSEUPHILLT, & 
  4:                 FREEZE, FROZEN, NFREEZE, PRINTPTS, TWOENDS, PV, DUMPMAG, NSTEPMIN, FIXAFTER, AMBER12T  4:                 FREEZE, FROZEN, NFREEZE, PRINTPTS, TWOENDS, PV, DUMPMAG, NSTEPMIN, FIXAFTER, AMBER12T
  5:   5: 
  6: USE COMMONS, ONLY : DEBUG  6: USE COMMONS, ONLY : DEBUG
  7:   7: 
  8: USE GENRIGID, ONLY : ATOMRIGIDCOORDT, DEGFREEDOMS, NRIGIDBODY, NSITEPERBODY, RIGIDGROUPS, MAXSITE, SITESRIGIDBODY, &   8: USE GENRIGID, ONLY : ATOMRIGIDCOORDT, DEGFREEDOMS, NRIGIDBODY, NSITEPERBODY, RIGIDGROUPS, MAXSITE, SITESRIGIDBODY, & 
  9:                      RIGIDSINGLES, IINVERSE, AACONVERGENCET  9:                      RIGIDSINGLES, IINVERSE
 10:  10: 
 11: USE INTCOMMONS, ONLY : BONDSFROMFILE 11: USE INTCOMMONS, ONLY : BONDSFROMFILE
 12:  12: 
 13: USE INTERNALS_WRAPPER, ONLY : INTWRAP_USEINTERNALS 13: USE INTERNALS_WRAPPER, ONLY : INTWRAP_USEINTERNALS
 14:  14: 
 15: USE MODAMBER9, ONLY : CHECKCISTRANSALWAYS, CHECKCISTRANSALWAYSDNA, CHECKCISTRANSALWAYSRNA 15: USE MODAMBER9, ONLY : CHECKCISTRANSALWAYS, CHECKCISTRANSALWAYSDNA, CHECKCISTRANSALWAYSRNA
 16:  16: 
 17: USE, INTRINSIC :: ISO_C_BINDING, ONLY: C_PTR, C_INT, C_DOUBLE, C_BOOL, C_CHAR 17: USE, INTRINSIC :: ISO_C_BINDING, ONLY: C_PTR, C_INT, C_DOUBLE, C_BOOL, C_CHAR
 18:  18: 
 19: IMPLICIT NONE 19: IMPLICIT NONE
 20:  20: 
 21: INTERFACE 21: INTERFACE
 22:     SUBROUTINE CUDA_LBFGS(N, C_XCOORDS, C_GMAX, C_MFLAG, C_ENERGY, ITMAX, C_ITDONE, C_MAXBFGS, C_MAXERISE, C_RMS, C_CUDAPOT, &  22:     SUBROUTINE CUDA_LBFGS(N, C_XCOORDS, C_GMAX, C_MFLAG, C_ENERGY, ITMAX, C_ITDONE, C_MAXBFGS, C_MAXERISE, C_RMS, C_CUDAPOT, & 
 23:                          C_DEBUG, C_CUDATIMET, NCALLS, C_COLDFUSION, C_COLDFUSIONLIMIT, C_DGUESS, MUPDATE, C_ATOMRIGIDCOORDT, &  23:                          C_DEBUG, C_CUDATIMET, NCALLS, C_COLDFUSION, C_COLDFUSIONLIMIT, C_DGUESS, MUPDATE, C_ATOMRIGIDCOORDT, & 
 24:                          C_DEGFREEDOMS, C_NRIGIDBODY, C_NSITEPERBODY, C_RIGIDGROUPS, C_MAXSITE, C_SITESRIGIDBODY, C_RIGIDSINGLES, &  24:                          C_DEGFREEDOMS, C_NRIGIDBODY, C_NSITEPERBODY, C_RIGIDGROUPS, C_MAXSITE, C_SITESRIGIDBODY, C_RIGIDSINGLES, & 
 25:                          C_BQMAX, C_IINVERSE, PROJECT, C_FREEZE, C_FROZEN, C_NFREEZE, POTENTIALTIME, C_AACONVERGENCET) &  25:                          C_BQMAX, C_IINVERSE, PROJECT, C_FREEZE, C_FROZEN, C_NFREEZE, POTENTIALTIME) BIND(C,NAME="setup_lbfgs")
 26:                          BIND(C,NAME="setup_lbfgs") 
 27:  26: 
 28:         IMPORT :: C_INT, C_DOUBLE, C_BOOL, C_CHAR 27:         IMPORT :: C_INT, C_DOUBLE, C_BOOL, C_CHAR
 29:  28: 
 30:         INTEGER(KIND=C_INT), INTENT(IN) :: N, & ! 3*no. of atoms 29:         INTEGER(KIND=C_INT), INTENT(IN) :: N, & ! 3*no. of atoms
 31:                                            ITMAX, & ! Max. no. of steps allowed in minmization 30:                                            ITMAX, & ! Max. no. of steps allowed in minmization
 32:                                            C_DEGFREEDOMS, & ! Rigid Body Framework (RBF): no. of degrees of freedom 31:                                            C_DEGFREEDOMS, & ! Rigid Body Framework (RBF): no. of degrees of freedom
 33:                                            C_NRIGIDBODY, & ! RBF: no. of rigid bodies 32:                                            C_NRIGIDBODY, & ! RBF: no. of rigid bodies
 34:                                            C_MAXSITE, & ! RBF: max. no. of sites in a rigid body 33:                                            C_MAXSITE, & ! RBF: max. no. of sites in a rigid body
 35:                                            MUPDATE, & ! History size 34:                                            MUPDATE, & ! History size
 36:                                            C_NFREEZE ! No. of frozen atoms 35:                                            C_NFREEZE ! No. of frozen atoms
 47:  46: 
 48:         REAL(KIND=C_DOUBLE), INTENT(IN) :: C_GMAX, & ! Convergence tolerance for RMS force  47:         REAL(KIND=C_DOUBLE), INTENT(IN) :: C_GMAX, & ! Convergence tolerance for RMS force 
 49:                                            C_MAXBFGS, & ! Max. step size allowed  48:                                            C_MAXBFGS, & ! Max. step size allowed 
 50:                                            C_MAXERISE, & ! Max. energy rise allowed  49:                                            C_MAXERISE, & ! Max. energy rise allowed 
 51:                                            C_COLDFUSIONLIMIT, & ! Limit below which cold fusion is diagnosed and minimization terminated 50:                                            C_COLDFUSIONLIMIT, & ! Limit below which cold fusion is diagnosed and minimization terminated
 52:                                            C_DGUESS, & ! Initial guess for inverse Hessian diagonal elements 51:                                            C_DGUESS, & ! Initial guess for inverse Hessian diagonal elements
 53:                                            C_BQMAX ! (1/5) of threshold under which aaconvergence is used, equivalent to C_GMAX 52:                                            C_BQMAX ! (1/5) of threshold under which aaconvergence is used, equivalent to C_GMAX
 54:  53: 
 55:         REAL(KIND=C_DOUBLE), DIMENSION(C_MAXSITE*3*C_NRIGIDBODY), INTENT(IN) :: C_SITESRIGIDBODY ! RBF: coordinates of the rigid body sites 54:         REAL(KIND=C_DOUBLE), DIMENSION(C_MAXSITE*3*C_NRIGIDBODY), INTENT(IN) :: C_SITESRIGIDBODY ! RBF: coordinates of the rigid body sites
 56:  55: 
 57:         REAL(KIND=C_DOUBLE), DIMENSION(C_NRIGIDBODY*3*3), INTENT(IN) :: C_IINVERSE ! RBF: inverse eigenvalues of the unweighted tensor of gyration 56:         REAL(KIND=C_DOUBLE), DIMENSION(C_NRIGIDBODY*3*3), INTENT(IN) :: C_IINVERSE ! RBF: from genrigid, used in aaconvergence subroutine
 58:  57: 
 59:         REAL(KIND=C_DOUBLE), DIMENSION(N), INTENT(INOUT) :: C_XCOORDS ! Coordinates 58:         REAL(KIND=C_DOUBLE), DIMENSION(N), INTENT(INOUT) :: C_XCOORDS ! Coordinates
 60:  59: 
 61:         REAL(KIND=C_DOUBLE), INTENT(OUT) :: C_ENERGY, & ! Energy 60:         REAL(KIND=C_DOUBLE), INTENT(OUT) :: C_ENERGY, & ! Energy
 62:                                             C_RMS, & ! RMS force 61:                                             C_RMS, & ! RMS force
 63:                                             POTENTIALTIME ! Time taken in calculating potential 62:                                             POTENTIALTIME ! Time taken in calculating potential
 64:  63: 
 65:         LOGICAL(KIND=C_BOOL), INTENT(IN) :: C_DEBUG, & ! If true, print debug info. 64:         LOGICAL(KIND=C_BOOL), INTENT(IN) :: C_DEBUG, & ! If true, print debug info.
 66:                                             C_CUDATIMET, & ! If true, print timing info. 65:                                             C_CUDATIMET, & ! If true, print timing info.
 67:                                             C_ATOMRIGIDCOORDT, & ! If false, use rigid body coordinates 66:                                             C_ATOMRIGIDCOORDT, & ! If false, use rigid body coordinates
 68:                                             PROJECT, & ! If true, project out the components of the gradient along the eigenvector 67:                                             PROJECT, & ! If true, project out the components of the gradient along the eigenvector
 69:                                             C_FREEZE, & ! If true, freeze some specified atoms 68:                                             C_FREEZE ! If true, freeze some specified atoms
 70:                                             C_AACONVERGENCET ! If true, use more accurate method of calculating rigid RMS force 
 71:  69: 
 72:         LOGICAL(KIND=C_BOOL), DIMENSION(N/3), INTENT(IN) :: C_FROZEN ! Logical array specifying frozen atoms 70:         LOGICAL(KIND=C_BOOL), DIMENSION(N/3), INTENT(IN) :: C_FROZEN ! Logical array specifying frozen atoms
 73:  71: 
 74:         LOGICAL(KIND=C_BOOL), INTENT(OUT) :: C_MFLAG, & ! True if quench converged 72:         LOGICAL(KIND=C_BOOL), INTENT(OUT) :: C_MFLAG, & ! True if quench converged
 75:                                              C_COLDFUSION ! Set to true during minimization if cold fusion diagnosed 73:                                              C_COLDFUSION ! Set to true during minimization if cold fusion diagnosed
 76:  74: 
 77:         CHARACTER(LEN=1, KIND=C_CHAR), INTENT(IN) :: C_CUDAPOT ! Character specifying the CUDA potential to be used 75:         CHARACTER(LEN=1, KIND=C_CHAR), INTENT(IN) :: C_CUDAPOT ! Character specifying the CUDA potential to be used
 78:  76: 
 79:     END SUBROUTINE CUDA_LBFGS 77:     END SUBROUTINE CUDA_LBFGS
 80: END INTERFACE 78: END INTERFACE
101:         INTEGER(KIND=C_INT) :: N, ITMAX, C_ITDONE, NCALLS, C_DEGFREEDOMS, C_NRIGIDBODY, C_MAXSITE, MUPDATE, C_NFREEZE 99:         INTEGER(KIND=C_INT) :: N, ITMAX, C_ITDONE, NCALLS, C_DEGFREEDOMS, C_NRIGIDBODY, C_MAXSITE, MUPDATE, C_NFREEZE
102:         INTEGER(KIND=C_INT), DIMENSION(NRIGIDBODY) :: C_NSITEPERBODY100:         INTEGER(KIND=C_INT), DIMENSION(NRIGIDBODY) :: C_NSITEPERBODY
103:         INTEGER(KIND=C_INT), DIMENSION(MAXSITE*NRIGIDBODY) :: C_RIGIDGROUPS101:         INTEGER(KIND=C_INT), DIMENSION(MAXSITE*NRIGIDBODY) :: C_RIGIDGROUPS
104:         INTEGER(KIND=C_INT), DIMENSION(DEGFREEDOMS/3 - 2*NRIGIDBODY) :: C_RIGIDSINGLES102:         INTEGER(KIND=C_INT), DIMENSION(DEGFREEDOMS/3 - 2*NRIGIDBODY) :: C_RIGIDSINGLES
105: 103: 
106:         REAL(KIND=C_DOUBLE) :: C_MAXBFGS, C_MAXERISE, C_ENERGY, C_RMS, C_COLDFUSIONLIMIT, C_DGUESS, C_BQMAX, C_GMAX, POTENTIALTIME104:         REAL(KIND=C_DOUBLE) :: C_MAXBFGS, C_MAXERISE, C_ENERGY, C_RMS, C_COLDFUSIONLIMIT, C_DGUESS, C_BQMAX, C_GMAX, POTENTIALTIME
107:         REAL(KIND=C_DOUBLE), DIMENSION(MAXSITE*3*NRIGIDBODY) :: C_SITESRIGIDBODY105:         REAL(KIND=C_DOUBLE), DIMENSION(MAXSITE*3*NRIGIDBODY) :: C_SITESRIGIDBODY
108:         REAL(KIND=C_DOUBLE), DIMENSION(NRIGIDBODY*3*3) :: C_IINVERSE106:         REAL(KIND=C_DOUBLE), DIMENSION(NRIGIDBODY*3*3) :: C_IINVERSE
109:         REAL(KIND=C_DOUBLE), DIMENSION(N) :: C_XCOORDS107:         REAL(KIND=C_DOUBLE), DIMENSION(N) :: C_XCOORDS
110: 108: 
111:         LOGICAL(KIND=C_BOOL) :: C_MFLAG, C_DEBUG, C_CUDATIMET, C_ATOMRIGIDCOORDT, C_COLDFUSION, PROJECT, C_FREEZE, C_AACONVERGENCET109:         LOGICAL(KIND=C_BOOL) :: C_MFLAG, C_DEBUG, C_CUDATIMET, C_ATOMRIGIDCOORDT, C_COLDFUSION, PROJECT, C_FREEZE
112:         LOGICAL(KIND=C_BOOL), DIMENSION(N/3) :: C_FROZEN110:         LOGICAL(KIND=C_BOOL), DIMENSION(N/3) :: C_FROZEN
113: 111: 
114:         CHARACTER(LEN=1, KIND=C_CHAR) :: C_CUDAPOT112:         CHARACTER(LEN=1, KIND=C_CHAR) :: C_CUDAPOT
115: 113: 
116:         ! Variables passed as *arguments through this wrapper* (not common) with intent out for CUDA_LBFGS are not passed into it114:         ! Variables passed as *arguments through this wrapper* (not common) with intent out for CUDA_LBFGS are not passed into it
117:         ! Therefore uninitialised C types are passed in and converted types are copied back after the call115:         ! Therefore uninitialised C types are passed in and converted types are copied back after the call
118: 116: 
119:         INTEGER :: I, J, K, ITDONE, FCALL, NPCALL, ECALL, SCALL117:         INTEGER :: I, J, K, ITDONE, FCALL, NPCALL, ECALL, SCALL
120:         DOUBLE PRECISION :: ENERGY, RMS, FTIME, ETIME, STIME118:         DOUBLE PRECISION :: ENERGY, RMS, FTIME, ETIME, STIME
121:         DOUBLE PRECISION, DIMENSION(N) :: XCOORDS119:         DOUBLE PRECISION, DIMENSION(N) :: XCOORDS
197:         C_ATOMRIGIDCOORDT = ATOMRIGIDCOORDT195:         C_ATOMRIGIDCOORDT = ATOMRIGIDCOORDT
198:         C_DEGFREEDOMS = DEGFREEDOMS196:         C_DEGFREEDOMS = DEGFREEDOMS
199:         C_NRIGIDBODY = NRIGIDBODY197:         C_NRIGIDBODY = NRIGIDBODY
200:         C_MAXSITE = MAXSITE198:         C_MAXSITE = MAXSITE
201:         C_COLDFUSIONLIMIT = COLDFUSIONLIMIT199:         C_COLDFUSIONLIMIT = COLDFUSIONLIMIT
202:         C_DGUESS = DGUESS200:         C_DGUESS = DGUESS
203:         C_BQMAX = GMAX201:         C_BQMAX = GMAX
204:         C_GMAX = GMAX202:         C_GMAX = GMAX
205:         C_FREEZE = FREEZE203:         C_FREEZE = FREEZE
206:         C_NFREEZE = NFREEZE204:         C_NFREEZE = NFREEZE
207:         C_AACONVERGENCET = AACONVERGENCET 
208: 205: 
209:         ! 'C_' prefix denotes those variables which have intent out or inout or are copies of those from common blocks/modules 206:         ! 'C_' prefix denotes those variables which have intent out or inout or are copies of those from common blocks/modules 
210:         CALL CUDA_LBFGS(N, C_XCOORDS, C_GMAX, C_MFLAG, C_ENERGY, ITMAX, C_ITDONE, C_MAXBFGS, C_MAXERISE, C_RMS, C_CUDAPOT, & 207:         CALL CUDA_LBFGS(N, C_XCOORDS, C_GMAX, C_MFLAG, C_ENERGY, ITMAX, C_ITDONE, C_MAXBFGS, C_MAXERISE, C_RMS, C_CUDAPOT, & 
211:                        C_DEBUG, C_CUDATIMET, NCALLS, C_COLDFUSION, C_COLDFUSIONLIMIT, C_DGUESS, MUPDATE, & 208:                        C_DEBUG, C_CUDATIMET, NCALLS, C_COLDFUSION, C_COLDFUSIONLIMIT, C_DGUESS, MUPDATE, & 
212:                        C_ATOMRIGIDCOORDT, C_DEGFREEDOMS, C_NRIGIDBODY, C_NSITEPERBODY, C_RIGIDGROUPS, C_MAXSITE, & 209:                        C_ATOMRIGIDCOORDT, C_DEGFREEDOMS, C_NRIGIDBODY, C_NSITEPERBODY, C_RIGIDGROUPS, C_MAXSITE, & 
213:                        C_SITESRIGIDBODY, C_RIGIDSINGLES, C_BQMAX, C_IINVERSE, PROJECT, C_FREEZE, C_FROZEN, C_NFREEZE, & 210:                        C_SITESRIGIDBODY, C_RIGIDSINGLES, C_BQMAX, C_IINVERSE, PROJECT, C_FREEZE, C_FROZEN, C_NFREEZE, & 
214:                        POTENTIALTIME, C_AACONVERGENCET)211:                        POTENTIALTIME)
215: 212: 
216:         ! Make sure C types with intent out or inout are coverted back to Fortran ones213:         ! Make sure C types with intent out or inout are coverted back to Fortran ones
217: 214: 
218:         DO I = 1,N215:         DO I = 1,N
219:             XCOORDS(I) = DBLE(C_XCOORDS(I))216:             XCOORDS(I) = DBLE(C_XCOORDS(I))
220:         END DO217:         END DO
221: 218: 
222:         ENERGY = DBLE(C_ENERGY)219:         ENERGY = DBLE(C_ENERGY)
223:         RMS = DBLE(C_RMS)220:         RMS = DBLE(C_RMS)
224:         MFLAG = LOGICAL(C_MFLAG)221:         MFLAG = LOGICAL(C_MFLAG)


r29335/modcudalbfgs.F90 2015-11-17 23:32:30.280106163 +0000 r29334/modcudalbfgs.F90 2015-11-17 23:32:32.584137064 +0000
  1: MODULE MODCUDALBFGS  1: MODULE MODCUDALBFGS
  2:   2: 
  3: #ifndef DUMMY_CUDA  3: #ifndef DUMMY_CUDA
  4:   4: 
  5: USE COMMONS, ONLY : RMS, DEBUG, CUDATIMET, MAXBFGS, MAXERISE, CUDAPOT, NPCALL, COLDFUSION, COLDFUSIONLIMIT, MYUNIT, DGUESS, &  5: USE COMMONS, ONLY : RMS, DEBUG, CUDATIMET, MAXBFGS, MAXERISE, CUDAPOT, NPCALL, COLDFUSION, COLDFUSIONLIMIT, MYUNIT, DGUESS, &
  6:                     BQMAX, FREEZE, SEEDT, FREEZECORE, FROZEN, NFREEZE, QUENCHDOS, CENT, CALCQT, INTMINT, DUMPT, COMPRESSRIGIDT, &   6:                     BQMAX, FREEZE, SEEDT, FREEZECORE, FROZEN, NFREEZE, QUENCHDOS, CENT, CALCQT, INTMINT, DUMPT, COMPRESSRIGIDT, & 
  7:                     AMBER12T  7:                     AMBER12T
  8:   8: 
  9: USE GENRIGID, ONLY : ATOMRIGIDCOORDT, DEGFREEDOMS, NRIGIDBODY, NSITEPERBODY, RIGIDGROUPS, MAXSITE, SITESRIGIDBODY, &   9: USE GENRIGID, ONLY : ATOMRIGIDCOORDT, DEGFREEDOMS, NRIGIDBODY, NSITEPERBODY, RIGIDGROUPS, MAXSITE, SITESRIGIDBODY, & 
 10:                      RIGIDSINGLES, IINVERSE, AACONVERGENCET 10:                      RIGIDSINGLES, IINVERSE
 11:  11: 
 12: USE MODAMBER9, ONLY : STEEREDMINT 12: USE MODAMBER9, ONLY : STEEREDMINT
 13:  13: 
 14: #endif 14: #endif
 15:  15: 
 16: USE, INTRINSIC :: ISO_C_BINDING, ONLY: C_PTR, C_INT, C_DOUBLE, C_BOOL, C_CHAR 16: USE, INTRINSIC :: ISO_C_BINDING, ONLY: C_PTR, C_INT, C_DOUBLE, C_BOOL, C_CHAR
 17:  17: 
 18: IMPLICIT NONE 18: IMPLICIT NONE
 19:  19: 
 20: #ifndef DUMMY_CUDA 20: #ifndef DUMMY_CUDA
 21: INTERFACE 21: INTERFACE
 22:     SUBROUTINE CUDA_LBFGS(N, C_XCOORDS, EPS, C_MFLAG, C_ENERGY, ITMAX, C_ITDONE, C_MAXBFGS, C_MAXERISE, C_RMS, C_CUDAPOT, &  22:     SUBROUTINE CUDA_LBFGS(N, C_XCOORDS, EPS, C_MFLAG, C_ENERGY, ITMAX, C_ITDONE, C_MAXBFGS, C_MAXERISE, C_RMS, C_CUDAPOT, & 
 23:                          C_DEBUG, C_CUDATIMET, ECALLS, C_COLDFUSION, C_COLDFUSIONLIMIT, & 23:                          C_DEBUG, C_CUDATIMET, ECALLS, C_COLDFUSION, C_COLDFUSIONLIMIT, &
 24:                          C_DGUESS, MUPDATE, C_ATOMRIGIDCOORDT, C_DEGFREEDOMS, C_NRIGIDBODY, C_NSITEPERBODY, & 24:                          C_DGUESS, MUPDATE, C_ATOMRIGIDCOORDT, C_DEGFREEDOMS, C_NRIGIDBODY, C_NSITEPERBODY, &
 25:                          C_RIGIDGROUPS, C_MAXSITE, C_SITESRIGIDBODY, C_RIGIDSINGLES, C_BQMAX, C_IINVERSE, & 25:                          C_RIGIDGROUPS, C_MAXSITE, C_SITESRIGIDBODY, C_RIGIDSINGLES, C_BQMAX, C_IINVERSE, &
 26:                          PROJECT, C_FREEZE, C_FROZEN, C_NFREEZE, POTENTIALTIME, C_AACONVERGENCET) BIND(C,NAME="setup_lbfgs") 26:                          PROJECT, C_FREEZE, C_FROZEN, C_NFREEZE, POTENTIALTIME) BIND(C,NAME="setup_lbfgs")
 27:  27: 
 28:         IMPORT :: C_INT, C_DOUBLE, C_BOOL, C_CHAR 28:         IMPORT :: C_INT, C_DOUBLE, C_BOOL, C_CHAR
 29:  29: 
 30:         INTEGER(KIND=C_INT), INTENT(IN) :: N, & ! 3*no. of atoms 30:         INTEGER(KIND=C_INT), INTENT(IN) :: N, & ! 3*no. of atoms
 31:                                            ITMAX, & ! Max. no. of steps allowed in minmization 31:                                            ITMAX, & ! Max. no. of steps allowed in minmization
 32:                                            C_DEGFREEDOMS, & ! Rigid Body Framework (RBF): no. of degrees of freedom 32:                                            C_DEGFREEDOMS, & ! Rigid Body Framework (RBF): no. of degrees of freedom
 33:                                            C_NRIGIDBODY, & ! RBF: no. of rigid bodies 33:                                            C_NRIGIDBODY, & ! RBF: no. of rigid bodies
 34:                                            C_MAXSITE, & ! RBF: max. no. of sites in a rigid body 34:                                            C_MAXSITE, & ! RBF: max. no. of sites in a rigid body
 35:                                            MUPDATE, & ! History size 35:                                            MUPDATE, & ! History size
 36:                                            C_NFREEZE ! No. of frozen atoms 36:                                            C_NFREEZE ! No. of frozen atoms
 46:  46: 
 47:         REAL(KIND=C_DOUBLE), INTENT(IN) :: EPS, & ! Convergence tolerance for RMS force 47:         REAL(KIND=C_DOUBLE), INTENT(IN) :: EPS, & ! Convergence tolerance for RMS force
 48:                                            C_MAXBFGS, & ! Max. step size allowed 48:                                            C_MAXBFGS, & ! Max. step size allowed
 49:                                            C_MAXERISE, & ! Max. energy rise allowed 49:                                            C_MAXERISE, & ! Max. energy rise allowed
 50:                                            C_COLDFUSIONLIMIT, & ! Limit below which cold fusion is diagnosed and minimization terminated 50:                                            C_COLDFUSIONLIMIT, & ! Limit below which cold fusion is diagnosed and minimization terminated
 51:                                            C_DGUESS, & ! Initial guess for inverse Hessian diagonal elements 51:                                            C_DGUESS, & ! Initial guess for inverse Hessian diagonal elements
 52:                                            C_BQMAX ! Sloppy quench tolerance for RMS gradient 52:                                            C_BQMAX ! Sloppy quench tolerance for RMS gradient
 53:  53: 
 54:         REAL(KIND=C_DOUBLE), DIMENSION(C_MAXSITE*3*C_NRIGIDBODY), INTENT(IN) :: C_SITESRIGIDBODY ! RBF: coordinates of the rigid body sites 54:         REAL(KIND=C_DOUBLE), DIMENSION(C_MAXSITE*3*C_NRIGIDBODY), INTENT(IN) :: C_SITESRIGIDBODY ! RBF: coordinates of the rigid body sites
 55:  55: 
 56:         REAL(KIND=C_DOUBLE), DIMENSION(C_NRIGIDBODY*3*3), INTENT(IN) :: C_IINVERSE ! RBF: inverse eigenvalues of the unweighted tensor of gyration 56:         REAL(KIND=C_DOUBLE), DIMENSION(C_NRIGIDBODY*3*3), INTENT(IN) :: C_IINVERSE ! RBF: from genrigid, used in aaconvergence subroutine
 57:  57: 
 58:         REAL(KIND=C_DOUBLE), DIMENSION(N), INTENT(INOUT) :: C_XCOORDS ! Coordinates 58:         REAL(KIND=C_DOUBLE), DIMENSION(N), INTENT(INOUT) :: C_XCOORDS ! Coordinates
 59:  59: 
 60:         REAL(KIND=C_DOUBLE), INTENT(OUT) :: C_ENERGY, & ! Energy 60:         REAL(KIND=C_DOUBLE), INTENT(OUT) :: C_ENERGY, & ! Energy
 61:                                             C_RMS, & ! RMS force 61:                                             C_RMS, & ! RMS force
 62:                                             POTENTIALTIME ! Time taken in calculating potential - not used in GMIN 62:                                             POTENTIALTIME ! Time taken in calculating potential - not used in GMIN
 63:  63: 
 64:         LOGICAL(KIND=C_BOOL), INTENT(IN) :: C_DEBUG, & ! If true, print debug info. 64:         LOGICAL(KIND=C_BOOL), INTENT(IN) :: C_DEBUG, & ! If true, print debug info.
 65:                                             C_CUDATIMET, & ! If true, print timing info.  65:                                             C_CUDATIMET, & ! If true, print timing info. 
 66:                                             C_ATOMRIGIDCOORDT, & ! If false, use rigid body coordinates 66:                                             C_ATOMRIGIDCOORDT, & ! If false, use rigid body coordinates
 67:                                             C_FREEZE, & ! If true, freeze some specified atoms 67:                                             C_FREEZE, & ! If true, freeze some specified atoms
 68:                                             PROJECT, & ! PROJECT is OPTIM only, always false 68:                                             PROJECT ! PROJECT is OPTIM only, always false
 69:                                             C_AACONVERGENCET ! If true, use more accurate method of calculating rigid RMS force 
 70:  69: 
 71:         LOGICAL(KIND=C_BOOL), DIMENSION(N/3), INTENT(IN) :: C_FROZEN ! Logical array specifying frozen atoms 70:         LOGICAL(KIND=C_BOOL), DIMENSION(N/3), INTENT(IN) :: C_FROZEN ! Logical array specifying frozen atoms
 72:  71: 
 73:         LOGICAL(KIND=C_BOOL), INTENT(OUT) :: C_MFLAG, & ! True if quench converged 72:         LOGICAL(KIND=C_BOOL), INTENT(OUT) :: C_MFLAG, & ! True if quench converged
 74:                                              C_COLDFUSION ! Set to true during minimization if cold fusion diagnosed 73:                                              C_COLDFUSION ! Set to true during minimization if cold fusion diagnosed
 75:  74: 
 76:         CHARACTER(LEN=1, KIND=C_CHAR), INTENT(IN) :: C_CUDAPOT ! Character specifying the CUDA potential to be used 75:         CHARACTER(LEN=1, KIND=C_CHAR), INTENT(IN) :: C_CUDAPOT ! Character specifying the CUDA potential to be used
 77:  76: 
 78:     END SUBROUTINE CUDA_LBFGS 77:     END SUBROUTINE CUDA_LBFGS
 79: END INTERFACE 78: END INTERFACE
102:         INTEGER(KIND=C_INT) :: N, MUPDATE, ITMAX, C_ITDONE, ECALLS, C_DEGFREEDOMS, C_NRIGIDBODY, C_MAXSITE, C_NFREEZE101:         INTEGER(KIND=C_INT) :: N, MUPDATE, ITMAX, C_ITDONE, ECALLS, C_DEGFREEDOMS, C_NRIGIDBODY, C_MAXSITE, C_NFREEZE
103:         INTEGER(KIND=C_INT), DIMENSION(NRIGIDBODY) :: C_NSITEPERBODY102:         INTEGER(KIND=C_INT), DIMENSION(NRIGIDBODY) :: C_NSITEPERBODY
104:         INTEGER(KIND=C_INT), DIMENSION(MAXSITE*NRIGIDBODY) :: C_RIGIDGROUPS103:         INTEGER(KIND=C_INT), DIMENSION(MAXSITE*NRIGIDBODY) :: C_RIGIDGROUPS
105:         INTEGER(KIND=C_INT), DIMENSION(DEGFREEDOMS/3 - 2*NRIGIDBODY) :: C_RIGIDSINGLES104:         INTEGER(KIND=C_INT), DIMENSION(DEGFREEDOMS/3 - 2*NRIGIDBODY) :: C_RIGIDSINGLES
106: 105: 
107:         REAL(KIND=C_DOUBLE) :: EPS, C_MAXBFGS, C_MAXERISE, C_ENERGY, C_RMS, C_COLDFUSIONLIMIT, C_DGUESS, C_BQMAX, POTENTIALTIME106:         REAL(KIND=C_DOUBLE) :: EPS, C_MAXBFGS, C_MAXERISE, C_ENERGY, C_RMS, C_COLDFUSIONLIMIT, C_DGUESS, C_BQMAX, POTENTIALTIME
108:         REAL(KIND=C_DOUBLE), DIMENSION(MAXSITE*3*NRIGIDBODY) :: C_SITESRIGIDBODY107:         REAL(KIND=C_DOUBLE), DIMENSION(MAXSITE*3*NRIGIDBODY) :: C_SITESRIGIDBODY
109:         REAL(KIND=C_DOUBLE), DIMENSION(NRIGIDBODY*3*3) :: C_IINVERSE108:         REAL(KIND=C_DOUBLE), DIMENSION(NRIGIDBODY*3*3) :: C_IINVERSE
110:         REAL(KIND=C_DOUBLE), DIMENSION(N) :: C_XCOORDS109:         REAL(KIND=C_DOUBLE), DIMENSION(N) :: C_XCOORDS
111: 110: 
112:         LOGICAL(KIND=C_BOOL) :: C_MFLAG, C_DEBUG, C_CUDATIMET, C_ATOMRIGIDCOORDT, C_COLDFUSION, C_FREEZE, PROJECT, C_AACONVERGENCET111:         LOGICAL(KIND=C_BOOL) :: C_MFLAG, C_DEBUG, C_CUDATIMET, C_ATOMRIGIDCOORDT, C_COLDFUSION, C_FREEZE, PROJECT
113:         LOGICAL(KIND=C_BOOL), DIMENSION(N/3) :: C_FROZEN112:         LOGICAL(KIND=C_BOOL), DIMENSION(N/3) :: C_FROZEN
114: 113: 
115:         CHARACTER(LEN=1, KIND=C_CHAR) :: C_CUDAPOT114:         CHARACTER(LEN=1, KIND=C_CHAR) :: C_CUDAPOT
116: #endif115: #endif
117:         ! Same as above, but now dimension(1).116:         ! Same as above, but now dimension(1).
118: #ifdef DUMMY_CUDA117: #ifdef DUMMY_CUDA
119:         INTEGER(KIND=C_INT) :: N, MUPDATE, ITMAX, C_ITDONE, ECALLS, C_DEGFREEDOMS, C_NRIGIDBODY, C_MAXSITE, C_NFREEZE118:         INTEGER(KIND=C_INT) :: N, MUPDATE, ITMAX, C_ITDONE, ECALLS, C_DEGFREEDOMS, C_NRIGIDBODY, C_MAXSITE, C_NFREEZE
120:         INTEGER(KIND=C_INT), DIMENSION(1) :: C_NSITEPERBODY119:         INTEGER(KIND=C_INT), DIMENSION(1) :: C_NSITEPERBODY
121:         INTEGER(KIND=C_INT), DIMENSION(1) :: C_RIGIDGROUPS120:         INTEGER(KIND=C_INT), DIMENSION(1) :: C_RIGIDGROUPS
122:         INTEGER(KIND=C_INT), DIMENSION(1) :: C_RIGIDSINGLES121:         INTEGER(KIND=C_INT), DIMENSION(1) :: C_RIGIDSINGLES
123: 122: 
124:         REAL(KIND=C_DOUBLE) :: EPS, C_MAXBFGS, C_MAXERISE, C_ENERGY, C_RMS, C_COLDFUSIONLIMIT, C_DGUESS, C_BQMAX, POTENTIALTIME123:         REAL(KIND=C_DOUBLE) :: EPS, C_MAXBFGS, C_MAXERISE, C_ENERGY, C_RMS, C_COLDFUSIONLIMIT, C_DGUESS, C_BQMAX, POTENTIALTIME
125:         REAL(KIND=C_DOUBLE), DIMENSION(1) :: C_SITESRIGIDBODY124:         REAL(KIND=C_DOUBLE), DIMENSION(1) :: C_SITESRIGIDBODY
126:         REAL(KIND=C_DOUBLE), DIMENSION(1) :: C_IINVERSE125:         REAL(KIND=C_DOUBLE), DIMENSION(1) :: C_IINVERSE
127:         REAL(KIND=C_DOUBLE), DIMENSION(1) :: C_XCOORDS126:         REAL(KIND=C_DOUBLE), DIMENSION(1) :: C_XCOORDS
128: 127: 
129:         LOGICAL(KIND=C_BOOL) :: C_MFLAG, C_DEBUG, C_CUDATIMET, C_ATOMRIGIDCOORDT, C_COLDFUSION, C_FREEZE, PROJECT, C_AACONVERGENCET128:         LOGICAL(KIND=C_BOOL) :: C_MFLAG, C_DEBUG, C_CUDATIMET, C_ATOMRIGIDCOORDT, C_COLDFUSION, C_FREEZE, PROJECT
130:         LOGICAL(KIND=C_BOOL), DIMENSION(N/3) :: C_FROZEN129:         LOGICAL(KIND=C_BOOL), DIMENSION(N/3) :: C_FROZEN
131: 130: 
132:         CHARACTER(LEN=1, KIND=C_CHAR) :: C_CUDAPOT131:         CHARACTER(LEN=1, KIND=C_CHAR) :: C_CUDAPOT
133: #endif132: #endif
134: 133: 
135:         ! Variables passed as *arguments through this wrapper* (not common) with intent out for CUDA_LBFGS are not passed into it134:         ! Variables passed as *arguments through this wrapper* (not common) with intent out for CUDA_LBFGS are not passed into it
136:         ! Therefore uninitialised C types are passed in and converted types are copied back after the call135:         ! Therefore uninitialised C types are passed in and converted types are copied back after the call
137: 136: 
138:         INTEGER :: I, J, K, ITDONE137:         INTEGER :: I, J, K, ITDONE
139:         DOUBLE PRECISION :: ENERGY, POTEL138:         DOUBLE PRECISION :: ENERGY, POTEL
206:         C_ATOMRIGIDCOORDT = ATOMRIGIDCOORDT205:         C_ATOMRIGIDCOORDT = ATOMRIGIDCOORDT
207:         C_DEGFREEDOMS = DEGFREEDOMS206:         C_DEGFREEDOMS = DEGFREEDOMS
208:         C_NRIGIDBODY = NRIGIDBODY207:         C_NRIGIDBODY = NRIGIDBODY
209:         C_MAXSITE = MAXSITE208:         C_MAXSITE = MAXSITE
210:         C_COLDFUSIONLIMIT = COLDFUSIONLIMIT209:         C_COLDFUSIONLIMIT = COLDFUSIONLIMIT
211:         C_DGUESS = DGUESS210:         C_DGUESS = DGUESS
212:         C_BQMAX = BQMAX211:         C_BQMAX = BQMAX
213:         C_FREEZE = FREEZE212:         C_FREEZE = FREEZE
214:         C_NFREEZE = NFREEZE213:         C_NFREEZE = NFREEZE
215:         PROJECT = .FALSE.214:         PROJECT = .FALSE.
216:         C_AACONVERGENCET = AACONVERGENCET 
217: 215: 
218:         ! 'C_' prefix denotes those variables which have intent out or inout or are copies of those from common blocks/modules 216:         ! 'C_' prefix denotes those variables which have intent out or inout or are copies of those from common blocks/modules 
219:         CALL CUDA_LBFGS(N, C_XCOORDS, EPS, C_MFLAG, C_ENERGY, ITMAX, C_ITDONE, C_MAXBFGS, C_MAXERISE, C_RMS, C_CUDAPOT, & 217:         CALL CUDA_LBFGS(N, C_XCOORDS, EPS, C_MFLAG, C_ENERGY, ITMAX, C_ITDONE, C_MAXBFGS, C_MAXERISE, C_RMS, C_CUDAPOT, & 
220:                        C_DEBUG, C_CUDATIMET, ECALLS, C_COLDFUSION, C_COLDFUSIONLIMIT, C_DGUESS, MUPDATE, & 218:                        C_DEBUG, C_CUDATIMET, ECALLS, C_COLDFUSION, C_COLDFUSIONLIMIT, C_DGUESS, MUPDATE, & 
221:                        C_ATOMRIGIDCOORDT, C_DEGFREEDOMS, C_NRIGIDBODY, C_NSITEPERBODY, C_RIGIDGROUPS, C_MAXSITE, & 219:                        C_ATOMRIGIDCOORDT, C_DEGFREEDOMS, C_NRIGIDBODY, C_NSITEPERBODY, C_RIGIDGROUPS, C_MAXSITE, & 
222:                        C_SITESRIGIDBODY, C_RIGIDSINGLES, C_BQMAX, C_IINVERSE, PROJECT, C_FREEZE, C_FROZEN, C_NFREEZE, & 220:                        C_SITESRIGIDBODY, C_RIGIDSINGLES, C_BQMAX, C_IINVERSE, PROJECT, C_FREEZE, C_FROZEN, C_NFREEZE, & 
223:                        POTENTIALTIME, C_AACONVERGENCET)221:                        POTENTIALTIME)
224: 222: 
225:         ! Make sure C types with intent out or inout are coverted back to Fortran ones223:         ! Make sure C types with intent out or inout are coverted back to Fortran ones
226: 224: 
227:         DO I = 1,N225:         DO I = 1,N
228:             XCOORDS(I) = DBLE(C_XCOORDS(I))226:             XCOORDS(I) = DBLE(C_XCOORDS(I))
229:         END DO227:         END DO
230: 228: 
231:         ENERGY = DBLE(C_ENERGY)229:         ENERGY = DBLE(C_ENERGY)
232:         RMS = DBLE(C_RMS)230:         RMS = DBLE(C_RMS)
233:         MFLAG = LOGICAL(C_MFLAG)231:         MFLAG = LOGICAL(C_MFLAG)


r29335/potential.h 2015-11-17 23:32:29.324093340 +0000 r29334/potential.h 2015-11-17 23:32:31.636124348 +0000
  9:   9: 
 10: #ifndef POTENTIAL_H 10: #ifndef POTENTIAL_H
 11: #define POTENTIAL_H 11: #define POTENTIAL_H
 12:  12: 
 13: class LjPotential : public CostFunction 13: class LjPotential : public CostFunction
 14: { 14: {
 15:         public: 15:         public:
 16:                 LjPotential(Printing &debugPrinting, Timer &timer_potential, Cublas &cublas, size_t numDimensions, int nDegFreedom,  16:                 LjPotential(Printing &debugPrinting, Timer &timer_potential, Cublas &cublas, size_t numDimensions, int nDegFreedom, 
 17:                                 int nRigidBody, int rigidMaxSite, int *nRigidSitesPerBody, int *rigidGroups, double *sitesRigidBody,  17:                                 int nRigidBody, int rigidMaxSite, int *nRigidSitesPerBody, int *rigidGroups, double *sitesRigidBody, 
 18:                                 int *rigidSingles, double *rigidInverse, double *coords, int nSecDiag, bool isAtomisticNotRigid,  18:                                 int *rigidSingles, double *rigidInverse, double *coords, int nSecDiag, bool isAtomisticNotRigid, 
 19:                                 double aaConvThreshold, double coldFusionLim, bool shouldFreeze, bool *isAtomFrozen, int nFreeze,  19:                                 double aaConvThreshold, double coldFusionLim, bool shouldFreeze, bool *isAtomFrozen, int nFreeze);
 20:                                 bool isAaConvergence); 
 21:  20: 
 22:                 void computeEnergyAndGradient(const double *d_x, double *d_f, double *d_gradf); 21:                 void computeEnergyAndGradient(const double *d_x, double *d_f, double *d_gradf);
 23: }; 22: };
 24:  23: 
 25: class AmberPotential : public CostFunction 24: class AmberPotential : public CostFunction
 26: { 25: {
 27:         public: 26:         public:
 28:                 AmberPotential(Printing &debugPrinting, Timer &timer_potential, Cublas &cublas, size_t numDimensions, int nDegFreedom,  27:                 AmberPotential(Printing &debugPrinting, Timer &timer_potential, Cublas &cublas, size_t numDimensions, int nDegFreedom, 
 29:                                 int nRigidBody, int rigidMaxSite, int *nRigidSitesPerBody, int *rigidGroups, double *sitesRigidBody,  28:                                 int nRigidBody, int rigidMaxSite, int *nRigidSitesPerBody, int *rigidGroups, double *sitesRigidBody, 
 30:                                 int *rigidSingles, double *rigidInverse, double *x, int nSecDiag, bool isAtomisticNotRigid,  29:                                 int *rigidSingles, double *rigidInverse, double *x, int nSecDiag, bool isAtomisticNotRigid, 
 31:                                 double aaConvThreshold, double coldFusionLim, bool shouldFreeze, bool *isAtomFrozen, int nFreeze,  30:                                 double aaConvThreshold, double coldFusionLim, bool shouldFreeze, bool *isAtomFrozen, int nFreeze);
 32:                                 bool isAaConvergence); 
 33:  31: 
 34:                 void computeEnergyAndGradient(const double *d_x, double *d_f, double *d_gradf); 32:                 void computeEnergyAndGradient(const double *d_x, double *d_f, double *d_gradf);
 35: }; 33: };
 36:  34: 
 37: #endif /* end of include guard: POTENTIAL_H */ 35: #endif /* end of include guard: POTENTIAL_H */


r29335/setup_bfgsts.cu 2015-11-17 23:32:28.760085777 +0000 r29334/setup_bfgsts.cu 2015-11-17 23:32:31.056116570 +0000
110: 110: 
111: 111: 
112: extern "C" void setup_bfgsts(int *nAtoms, double *coords, double *xGradEps, _Bool *isConverged, double *energy, int *xMaxIter, 112: extern "C" void setup_bfgsts(int *nAtoms, double *coords, double *xGradEps, _Bool *isConverged, double *energy, int *xMaxIter, 
113:                 int *bItMax, int *bIter, double *xMaxStep, double *xMaxFkRise, double *outRms, char *cudaPotential, 113:                 int *bItMax, int *bIter, double *xMaxStep, double *xMaxFkRise, double *outRms, char *cudaPotential, 
114:                 _Bool *printDebug, _Bool *timeCuda, int *nPotCalls, _Bool *isColdFusion, double *coldFusionLim, double *xH0, 114:                 _Bool *printDebug, _Bool *timeCuda, int *nPotCalls, _Bool *isColdFusion, double *coldFusionLim, double *xH0, 
115:                 int *xUpdates, double *evalMin, double *evec, _Bool *isAtomisticNotRigid, int *nDegFreedomF, int *nRigidBodyF, 115:                 int *xUpdates, double *evalMin, double *evec, _Bool *isAtomisticNotRigid, int *nDegFreedomF, int *nRigidBodyF, 
116:                 int *nRigidSitesPerBodyF, int *rigidGroupsF, int *rigidMaxSiteF, double *sitesRigidBodyF, int *rigidSinglesF, 116:                 int *nRigidSitesPerBodyF, int *rigidGroupsF, int *rigidMaxSiteF, double *sitesRigidBodyF, int *rigidSinglesF, 
117:                 double *rigidInverseF, int *nSecDiag, double *evalPercentEps, double *pushOffCut, double *pushOffMag, 117:                 double *rigidInverseF, int *nSecDiag, double *evalPercentEps, double *pushOffCut, double *pushOffMag, 
118:                 double *maxEvecStep, double *maxMaxStep, double *minMaxStep, double *trustRadius, int *pMaxIter1, int *pMaxIter2, 118:                 double *maxEvecStep, double *maxMaxStep, double *minMaxStep, double *trustRadius, int *pMaxIter1, int *pMaxIter2, 
119:                 double *evecOverlapTol, int *pUpdates, double *gradEps, double *pMaxStep, double *pMaxFkRise, double *pH0, 119:                 double *evecOverlapTol, int *pUpdates, double *gradEps, double *pMaxStep, double *pMaxFkRise, double *pH0, 
120:                 double *evStepMagTol, _Bool *shouldFreeze, _Bool *isAtomFrozen, int *nFreeze, double *potTimeElapsed, 120:                 double *evStepMagTol, _Bool *shouldFreeze, _Bool *isAtomFrozen, int *nFreeze, double *potTimeElapsed)
121:                 bool *isAaConvergence) 
122: {121: {
123:         const size_t numDimensions = 3*(*nAtoms);122:         const size_t numDimensions = 3*(*nAtoms);
124:         const double aaConvThreshold = 5*(*gradEps);123:         const double aaConvThreshold = 5*(*gradEps);
125: 124: 
126:         // Rigid body parameters may not be intialised in Fortran code if rigid body framework not being used. 125:         // Rigid body parameters may not be intialised in Fortran code if rigid body framework not being used. 
127:         int nDegFreedom  = 0;126:         int nDegFreedom  = 0;
128:         int nRigidBody   = 0;127:         int nRigidBody   = 0;
129:         int rigidMaxSite = 0;128:         int rigidMaxSite = 0;
130: 129: 
131:         int *nRigidSitesPerBody = NULL;130:         int *nRigidSitesPerBody = NULL;
161:         // L specifies the Lennard-Jones potential for up to 1024 atoms. 160:         // L specifies the Lennard-Jones potential for up to 1024 atoms. 
162:         if (*cudaPotential == 'L') {161:         if (*cudaPotential == 'L') {
163:                 const size_t atomMax = 1024;162:                 const size_t atomMax = 1024;
164:                 if (numDimensions > 3*atomMax) {163:                 if (numDimensions > 3*atomMax) {
165:                         std::cerr << "Lennard-Jones is currently only supported for a maximum of 1024 atoms. " << std::endl;164:                         std::cerr << "Lennard-Jones is currently only supported for a maximum of 1024 atoms. " << std::endl;
166:                         exit(EXIT_FAILURE);165:                         exit(EXIT_FAILURE);
167:                 }166:                 }
168:                 // Create an instance of the appropriate class for the potential, LjPotential. 167:                 // Create an instance of the appropriate class for the potential, LjPotential. 
169:                 LjPotential potential(debugPrinting, timer_potential, cublas, numDimensions, nDegFreedom, nRigidBody, rigidMaxSite, 168:                 LjPotential potential(debugPrinting, timer_potential, cublas, numDimensions, nDegFreedom, nRigidBody, rigidMaxSite, 
170:                                 nRigidSitesPerBody, rigidGroups, sitesRigidBody, rigidSingles, rigidInverse, coords, 169:                                 nRigidSitesPerBody, rigidGroups, sitesRigidBody, rigidSingles, rigidInverse, coords, 
171:                                 *nSecDiag, *isAtomisticNotRigid, aaConvThreshold, *coldFusionLim, *shouldFreeze, isAtomFrozen, 170:                                 *nSecDiag, *isAtomisticNotRigid, aaConvThreshold, *coldFusionLim, *shouldFreeze, isAtomFrozen, *nFreeze);
172:                                 *nFreeze, *isAaConvergence); 
173: 171: 
174:                 setup<LjPotential>(debugPrinting, cublas, numDimensions, xGradEps, isConverged, energy, xMaxIter, bIter, xMaxStep, xMaxFkRise, 172:                 setup<LjPotential>(debugPrinting, cublas, numDimensions, xGradEps, isConverged, energy, xMaxIter, bIter, xMaxStep, xMaxFkRise, 
175:                                 outRms, potential, printDebug, timeCuda, nPotCalls, isColdFusion, coldFusionLim, xH0, xUpdates, 173:                                 outRms, potential, printDebug, timeCuda, nPotCalls, isColdFusion, coldFusionLim, xH0, xUpdates, 
176:                                 evec, evalPercentEps, evalMin, coords, pushOffCut, pushOffMag, maxEvecStep, maxMaxStep, 174:                                 evec, evalPercentEps, evalMin, coords, pushOffCut, pushOffMag, maxEvecStep, maxMaxStep, 
177:                                 minMaxStep, trustRadius, pMaxIter1, pMaxIter2, bItMax, evecOverlapTol, pUpdates, gradEps, 175:                                 minMaxStep, trustRadius, pMaxIter1, pMaxIter2, bItMax, evecOverlapTol, pUpdates, gradEps, 
178:                                 pMaxStep, pMaxFkRise, pH0, evStepMagTol);176:                                 pMaxStep, pMaxFkRise, pH0, evStepMagTol);
179:         }177:         }
180:         // A specifies the AMBER potential. 178:         // A specifies the AMBER potential. 
181:         else if (*cudaPotential == 'A') {179:         else if (*cudaPotential == 'A') {
182:                 AmberPotential potential(debugPrinting, timer_potential, cublas, numDimensions, nDegFreedom, nRigidBody, rigidMaxSite, 180:                 AmberPotential potential(debugPrinting, timer_potential, cublas, numDimensions, nDegFreedom, nRigidBody, 
183:                                 nRigidSitesPerBody, rigidGroups, sitesRigidBody, rigidSingles, rigidInverse, coords, 181:                                 rigidMaxSite, nRigidSitesPerBody, rigidGroups, sitesRigidBody, rigidSingles, rigidInverse, 
184:                                 *nSecDiag, *isAtomisticNotRigid, aaConvThreshold, *coldFusionLim, *shouldFreeze, isAtomFrozen, 182:                                 coords, *nSecDiag, *isAtomisticNotRigid, aaConvThreshold, *coldFusionLim, *shouldFreeze, 
185:                                 *nFreeze, *isAaConvergence);183:                                 isAtomFrozen, *nFreeze);
186: 184: 
187:                 setup<AmberPotential>(debugPrinting, cublas, numDimensions, xGradEps, isConverged, energy, xMaxIter, bIter, xMaxStep, xMaxFkRise, 185:                 setup<AmberPotential>(debugPrinting, cublas, numDimensions, xGradEps, isConverged, energy, xMaxIter, bIter, xMaxStep, xMaxFkRise, 
188:                                 outRms, potential, printDebug, timeCuda, nPotCalls, isColdFusion, coldFusionLim, xH0, 186:                                 outRms, potential, printDebug, timeCuda, nPotCalls, isColdFusion, coldFusionLim, xH0, 
189:                                 xUpdates, evec, evalPercentEps, evalMin, coords, pushOffCut, pushOffMag, maxEvecStep, 187:                                 xUpdates, evec, evalPercentEps, evalMin, coords, pushOffCut, pushOffMag, maxEvecStep, 
190:                                 maxMaxStep, minMaxStep, trustRadius, pMaxIter1, pMaxIter2, bItMax, evecOverlapTol, pUpdates, 188:                                 maxMaxStep, minMaxStep, trustRadius, pMaxIter1, pMaxIter2, bItMax, evecOverlapTol, pUpdates, 
191:                                 gradEps, pMaxStep, pMaxFkRise, pH0, evStepMagTol);189:                                 gradEps, pMaxStep, pMaxFkRise, pH0, evStepMagTol);
192:         }190:         }
193:         else {191:         else {
194:                 std::cerr << "The specified potential has not been recognised. " << std::endl;192:                 std::cerr << "The specified potential has not been recognised. " << std::endl;
195:                 exit(EXIT_FAILURE);193:                 exit(EXIT_FAILURE);


r29335/setup_lbfgs.cu 2015-11-17 23:32:29.512095861 +0000 r29334/setup_lbfgs.cu 2015-11-17 23:32:31.824126872 +0000
 74: } 74: }
 75:  75: 
 76:  76: 
 77:  77: 
 78: extern "C" void setup_lbfgs(int *n, double *x, double *gradEps, _Bool *isConverged, double *energy, int *maxIter, int *itDone,  78: extern "C" void setup_lbfgs(int *n, double *x, double *gradEps, _Bool *isConverged, double *energy, int *maxIter, int *itDone, 
 79:                 double *maxStep, double *maxFkRise, double *outRms, char *cudaPot, _Bool *printDebug, _Bool *timeCuda,  79:                 double *maxStep, double *maxFkRise, double *outRms, char *cudaPot, _Bool *printDebug, _Bool *timeCuda, 
 80:                 int *nPotCalls, _Bool *isColdFusion, double *coldFusionLim, double *H0, int *updates,  80:                 int *nPotCalls, _Bool *isColdFusion, double *coldFusionLim, double *H0, int *updates, 
 81:                 _Bool *isAtomisticNotRigid, int *nDegFreedomF, int *nRigidBodyF, int *nRigidSitesPerBodyF,  81:                 _Bool *isAtomisticNotRigid, int *nDegFreedomF, int *nRigidBodyF, int *nRigidSitesPerBodyF, 
 82:                 int *rigidGroupsF, int *rigidMaxSiteF, double *sitesRigidBodyF, int *rigidSinglesF,  82:                 int *rigidGroupsF, int *rigidMaxSiteF, double *sitesRigidBodyF, int *rigidSinglesF, 
 83:                 double *aaConvThresholdF, double *rigidInverseF, _Bool *projectGrad, _Bool *shouldFreeze,  83:                 double *aaConvThresholdF, double *rigidInverseF, _Bool *projectGrad, _Bool *shouldFreeze, 
 84:                 _Bool *isAtomFrozen, int *nFreeze, double *potTimeElapsed, bool *isAaConvergence) 84:                 _Bool *isAtomFrozen, int *nFreeze, double *potTimeElapsed)
 85: { 85: {
 86:         const size_t numDimensions = *n; 86:         const size_t numDimensions = *n;
 87:  87: 
 88:         const int nSecDiag = 0; 88:         const int nSecDiag = 0;
 89:  89: 
 90:         const double aaConvThreshold = 5*(*aaConvThresholdF); 90:         const double aaConvThreshold = 5*(*aaConvThresholdF);
 91:  91: 
 92:         // Rigid body parameters may not be intialised if rigid body framework not being used. 92:         // Rigid body parameters may not be intialised if rigid body framework not being used.
 93:         int nDegFreedom  = 0; 93:         int nDegFreedom  = 0;
 94:         int nRigidBody   = 0; 94:         int nRigidBody   = 0;
127:         Cublas cublas;127:         Cublas cublas;
128: 128: 
129:         // L specifies the Lennard-Jones potential for up to 1024 atoms.129:         // L specifies the Lennard-Jones potential for up to 1024 atoms.
130:         if (*cudaPot == 'L') {130:         if (*cudaPot == 'L') {
131:                 const size_t atom_max = 1024;131:                 const size_t atom_max = 1024;
132:                 if (numDimensions > 3*atom_max) {132:                 if (numDimensions > 3*atom_max) {
133:                         std::cerr << "Lennard-Jones is currently only supported for a maximum of 1024 atoms. " << std::endl;133:                         std::cerr << "Lennard-Jones is currently only supported for a maximum of 1024 atoms. " << std::endl;
134:                         exit(EXIT_FAILURE);134:                         exit(EXIT_FAILURE);
135:                 }135:                 }
136:                 // Create an instance of the appropriate class for the potential, LjPotential.136:                 // Create an instance of the appropriate class for the potential, LjPotential.
137:                 LjPotential potential(debugPrinting, timer_potential, cublas, numDimensions, nDegFreedom, nRigidBody, 137:                 LjPotential potential(debugPrinting, timer_potential, cublas, numDimensions, nDegFreedom, nRigidBody, rigidMaxSite, nRigidSitesPerBody, rigidGroups, sitesRigidBody, rigidSingles, rigidInverse, coords, nSecDiag, *isAtomisticNotRigid, aaConvThreshold, *coldFusionLim, *shouldFreeze, isAtomFrozen, *nFreeze);
138:                                 rigidMaxSite, nRigidSitesPerBody, rigidGroups, sitesRigidBody, rigidSingles, rigidInverse, 138: 
139:                                 coords, nSecDiag, *isAtomisticNotRigid, aaConvThreshold, *coldFusionLim, *shouldFreeze, 139:                 setup<LjPotential>(debugPrinting, cublas, numDimensions, x, gradEps, isConverged, energy, maxIter, itDone, maxStep, maxFkRise, outRms, potential, printDebug, timeCuda, nPotCalls, H0, updates, isColdFusion, projectGrad);
140:                                 isAtomFrozen, *nFreeze, *isAaConvergence); 
141:  
142:                 setup<LjPotential>(debugPrinting, cublas, numDimensions, x, gradEps, isConverged, energy, maxIter, itDone,  
143:                                 maxStep, maxFkRise, outRms, potential, printDebug, timeCuda, nPotCalls, H0, updates, isColdFusion,  
144:                                 projectGrad); 
145:         }140:         }
146:         // A specifies the AMBER potential.141:         // A specifies the AMBER potential.
147:         else if (*cudaPot == 'A') {142:         else if (*cudaPot == 'A') {
148:                 AmberPotential potential(debugPrinting, timer_potential, cublas, numDimensions, nDegFreedom, nRigidBody, 143:                 AmberPotential potential(debugPrinting, timer_potential, cublas, numDimensions, nDegFreedom, nRigidBody, rigidMaxSite, nRigidSitesPerBody, rigidGroups, sitesRigidBody, rigidSingles, rigidInverse, coords, nSecDiag, *isAtomisticNotRigid, aaConvThreshold, *coldFusionLim, *shouldFreeze, isAtomFrozen, *nFreeze);
149:                                 rigidMaxSite, nRigidSitesPerBody, rigidGroups, sitesRigidBody, rigidSingles, rigidInverse, 144:                 setup<AmberPotential>(debugPrinting, cublas, numDimensions, x, gradEps, isConverged, energy, maxIter, itDone, maxStep, maxFkRise, outRms, potential, printDebug, timeCuda, nPotCalls, H0, updates, isColdFusion, projectGrad); 
150:                                 coords, nSecDiag, *isAtomisticNotRigid, aaConvThreshold, *coldFusionLim, *shouldFreeze,  
151:                                 isAtomFrozen, *nFreeze, *isAaConvergence); 
152:  
153:                 setup<AmberPotential>(debugPrinting, cublas, numDimensions, x, gradEps, isConverged, energy, maxIter, itDone,  
154:                                 maxStep, maxFkRise, outRms, potential, printDebug, timeCuda, nPotCalls, H0, updates, isColdFusion,  
155:                                 projectGrad);  
156:         }145:         }
157:         else {146:         else {
158:                 std::cerr << "The specified potential has not been recognised" << std::endl;147:                 std::cerr << "The specified potential has not been recognised" << std::endl;
159:                 exit(EXIT_FAILURE);148:                 exit(EXIT_FAILURE);
160:         }149:         }
161: 150: 
162:         if (*timeCuda) {151:         if (*timeCuda) {
163:                 timer_potential.saveMeasurement();152:                 timer_potential.saveMeasurement();
164:         }153:         }
165: 154: 


legend
Lines Added 
Lines changed
 Lines Removed

hdiff - version: 2.1.0