void NormalModeMinimizer::initialize(ProtoMolApp* app){
STSIntegrator::initialize(app);
initializeForces();
myPreviousNormalMode = dynamic_cast<NormalModeUtilities*>(myPreviousIntegrator);
//Check if using complement of prev integrator, then copy all integrator paramiters
if(firstMode == -1 && numMode == -1){
firstMode = myPreviousNormalMode->firstMode; numMode = myPreviousNormalMode->numMode;
myGamma = myPreviousNormalMode->myGamma; mySeed = myPreviousNormalMode->mySeed; myTemp = myPreviousNormalMode->myTemp;
}
//NM initialization if OK
NormalModeUtilities::initialize((int)app->positions.size(), app,
myForces, COMPLIMENT_FORCES); //last for complimentary forces, no gen noise
//
//initialize minimizer noise vars
randStp = 0.0;
//***********************************************************
//diagnostics
avItrs = 0; //average number of minimizer iterations/force calcs
avMinForceCalc = 0;
numSteps = 0; //total steps
//Set up minimum limit
app->eigenInfo.myMinimumLimit = minLim;
//
gaussRandCoord1.zero(-1); //zero vector for use as random force
}
void NormalModeMori::initialize(ProtoMolApp* app){
MTSIntegrator::initialize(app);
//
//point to bottom integrator, for average force
myBottomNormalMode = dynamic_cast<NormalModeUtilities*>(bottom());
//check valid eigenvectors
//NM initialization if OK
NormalModeUtilities::initialize((int)app->positions.size(), app, myForces, NO_NM_FLAGS); //last for non-complimentary forces
//
//do first force calculation, and remove non sub-space part
app->energies.clear(); //Need this or initial error, due to inner integrator energy?
initializeForces();
//
//take initial C velocites from system and remove non-subspace part
if(*Q != NULL) subspaceVelocity(&app->velocities, &app->velocities);
//
//####diagnostics
if(modeOutput != ""){
//save initial positions
ex0 = new Vector3DBlock;
*ex0 = app->positions;
ofstream myFile;
myFile.open(modeOutput.c_str(),ofstream::out);
//close file
myFile.close();
}
}
void NormalModeQuadratic::initialize( ProtoMolApp* app )
{
STSIntegrator::initialize( app );
initializeForces();
//if previous NM then it is diagonalize, so find pointer
if ( top() != this ) {
myPreviousNormalMode = dynamic_cast<NormalModeUtilities*>( myPreviousIntegrator );
} else {
myPreviousNormalMode = 0;
}
//NM initialization if OK //last for complimentary forces, no gen noise
NormalModeUtilities::initialize( ( int )app->positions.size(), app, myForces, COMPLIMENT_FORCES );
//modes
cPos = new double[_3N];
std::fill( cPos, cPos + _3N, 0.0 );
//total steps
numSteps = 0;
currMode = firstMode - 1;
if ( stepModes ) {
app->eigenInfo.currentMode = firstMode;
}
//save initial positions
ex0 = new Vector3DBlock;
*ex0 = app->positions;
total_time = 0.0;
}
void NormalModeLangLf::initialize(ProtoMolApp *app){
MTSIntegrator::initialize(app);
//check valid eigenvectors
//NM initialization if OK
int nm_flags = NO_NM_FLAGS;
if(genCompNoise) nm_flags |= GEN_COMP_NOISE;
NormalModeUtilities::initialize((int)app->positions.size(), app, myForces, nm_flags); //last int for no complimentary forces or gen noise: GEN_COMP_NOISE
//
//do first force calculation, and remove non sub-space part
app->energies.clear(); //Need this or initial error, due to inner integrator energy?
initializeForces();
//
//take initial C velocites from system and remove non-subspace part
if(*Q != NULL) subspaceVelocity(&app->velocities, &app->velocities);
//
}
void NormalModeRelax::initialize(ProtoMolApp* app){
MTSIntegrator::initialize(app);
//test not topmost integrator
if(top() == this) report << error << "NormalModeRelax cannot be top integrator."<<endr;
//
initializeForces();
//
myPreviousNormalMode = dynamic_cast<NormalModeUtilities*>(myPreviousIntegrator);
//check valid eigenvectors
firstMode = myPreviousNormalMode->firstMode; numMode = myPreviousNormalMode->numMode;
//NM initialization if OK
NormalModeUtilities::initialize((int)app->positions.size(), app, myForces, COMPLIMENT_FORCES); //last for complimentary forces
//
app->energies.clear(); //Need this or initial error, due to inner integrator energy?
//
//diagnostics
avItrs = 0; //average number of minimizer iterations/force calcs
avMinForceCalc = 0;
numSteps = 0; //total steps
}
void NormalModeOpenMM::initialize( ProtoMolApp *app ) {
report << plain << "OpenMM NML Vector information: Vector number " << app->eigenInfo.myNumEigenvectors << ", length " << app->eigenInfo.myEigenvectorLength << "." << endr;
//NM initialization
NormalModeUtilities::initialize( ( int )app->positions.size(), app,
myForces, NO_NM_FLAGS );
//Set up minimum limit
app->eigenInfo.myMinimumLimit = mMinimizationLimit;
//Set number of eigenvectors in use
app->eigenInfo.myNumUsedEigenvectors = _rfM;
// Setup LTMD Parameters
mLTMDParameters.blockDelta = mBlockDelta * Constant::ANGSTROM_NM;
mLTMDParameters.sDelta = mSDelta * Constant::ANGSTROM_NM;
mLTMDParameters.bdof = mBlockDOF;
mLTMDParameters.res_per_block = mResiduesPerBlock;
mLTMDParameters.modes = mModes;
mLTMDParameters.rediagFreq = mRediagonalizationFrequency;
mLTMDParameters.minLimit = mMinimizationLimit * Constant::KCAL_KJ;
if( mProtomolDiagonalize ) {
mLTMDParameters.ShouldProtoMolDiagonalize = true;
std::cout << "Block Diagonalization: ProtoMol" << std::endl;
} else {
mLTMDParameters.ShouldProtoMolDiagonalize = false;
std::cout << "Block Diagonalization: OpenMM" << std::endl;
}
if( shoudForceRediagOnMinFail ) {
mLTMDParameters.ShouldForceRediagOnMinFail = true;
std::cout << "Failure Rediagonalization: True" << std::endl;
} else {
mLTMDParameters.ShouldForceRediagOnMinFail = false;
std::cout << "Failure Rediagonalization: False" << std::endl;
}
if( mRediagOnQuadratic ){
mLTMDParameters.ShouldForceRediagOnQuadratic = true;
std::cout << "Force Rediagonalization on Quadratic Minimization: True" << std::endl;
}else{
mLTMDParameters.ShouldForceRediagOnQuadratic = false;
std::cout << "Force Rediagonalization on Quadratic Minimization: False" << std::endl;
}
if( !mProtomolDiagonalize ){
switch( mBlockPlatform ){
case 0: // Reference
std::cout << "OpenMM Block Diagonalization Platform: Reference" << std::endl;
mLTMDParameters.BlockDiagonalizePlatform = OpenMM::LTMD::Preference::Reference;
break;
case 1: // OpenCL
std::cout << "OpenMM Block Diagonalization Platform: OpenCL" << std::endl;
mLTMDParameters.BlockDiagonalizePlatform = OpenMM::LTMD::Preference::OpenCL;
break;
case 2: // CUDA
std::cout << "OpenMM Block Diagonalization Platform: CUDA" << std::endl;
mLTMDParameters.BlockDiagonalizePlatform = OpenMM::LTMD::Preference::CUDA;
break;
}
}
int current_res = app->topology->atoms[0].residue_seq;
int res_size = 0;
for( int i = 0; i < app->topology->atoms.size(); i++ ) {
if( app->topology->atoms[i].residue_seq != current_res ) {
mLTMDParameters.residue_sizes.push_back( res_size );
current_res = app->topology->atoms[i].residue_seq;
res_size = 0;
}
res_size++;
}
mLTMDParameters.residue_sizes.push_back( res_size );
if( mLTMDParameters.ShouldProtoMolDiagonalize ){
//app->eigenInfo.OpenMMMinimize = true;
}
//initialize base
OpenMMIntegrator::initialize( app );
initializeForces();
}
