/*
* Zero forces on all local atoms and optionally on ghosts.
*/
void AtomStorage::zeroForces(bool zeroGhosts)
{
int factor = 2;
// Zero forces for all local atoms
if (nAtom() > atomCapacity_/factor) {
atoms_.zeroForces();
// Optimization to allow sequential access
} else {
AtomIterator atomIter;
begin(atomIter);
for( ; atomIter.notEnd(); ++atomIter){
atomIter->force().zero();
}
}
// If using reverse communication, zero ghost atoms
if (zeroGhosts && nGhost()) {
if (nGhost() > ghostCapacity_/factor) {
ghosts_.zeroForces();
// Optimization to allow sequential access
} else {
GhostIterator ghostIter;
begin(ghostIter);
for( ; ghostIter.notEnd(); ++ghostIter){
ghostIter->force().zero();
}
}
}
}
void BondGeometry::calculateCurrentBondGeometry(const Structure& structure) {
int bondIndex = 0;
for (AtomIterator iterator = structure.getAtomIterator();
!iterator.isDone(); iterator.next()) {
Atom atom = iterator.getCurrentAtom();
setBondsForAnAtom(atom, bondIndex);
}
}
void IMGDock::reassignForces()
{
int i = 0;
for (AtomIterator it = ligand_->beginAtom(); !it.isEnd(); it++)
{
it->setForce(old_forces_[i]);
i++;
}
}
void IMGDock::storeForces()
{
int i = 0;
for (AtomIterator it = ligand_->beginAtom(); !it.isEnd(); it++)
{
old_forces_[i] = it->getForce();
i++;
}
}
void IMGDock::resetRotations()
{
current_conformation_ = vector < int > (current_conformation_.size(), 0);
int atom = 0;
for (AtomIterator it = ligand_->beginAtom(); +it; it++, atom++)
{
it->setPosition(original_atom_positions_[atom]);
}
}
void IMGDock::saveAtomPositions()
{
original_atom_positions_.resize(scoring_function_->getNoLigandAtoms());
Size atom = 0;
for (AtomIterator it = ligand_->beginAtom(); +it; it++, atom++)
{
original_atom_positions_[atom] = it->getPosition();
}
}
void IMGDock::translateLigand(Vector3& v)
{
TMatrix4x4<float> M;
M.setTranslation(v);
// transform all atoms of the ligand
for (AtomIterator it = ligand_->beginAtom(); it != ligand_->endAtom(); it++)
{
it->setPosition(M*it->getPosition());
}
}
void GridAnalysis::moveProbeGroup_(const Vector3& destination)
{
TMatrix4x4<float> M;
Vector3 translation_vector = destination-center_;
M.setTranslation(translation_vector);
for (AtomIterator it = probe_group_.beginAtom(); +it; it++)
{
it->setPosition(M*it->getPosition());
}
center_ = destination;
}
void GridAnalysis::rotateProbeGroup_(int axis, int degree)
{
TMatrix4x4<float> M;
TAngle<float> angle(degree, false);
Vector3 axis_vector(axis == 0, axis == 1, axis == 2);
M.setRotation(angle, axis_vector);
for (AtomIterator it = probe_group_.beginAtom(); it != probe_group_.endAtom(); it++)
{
it->setPosition(M*(it->getPosition()-center_)+center_);
}
}
void IMGDock::rotateLigand(int a, int degree)
{
TMatrix4x4<float> M;
TAngle<float> angle(degree, false);
Vector3 axis(a == 0, a == 1, a == 2);
M.setRotation(angle, axis);
const Vector3& origin = scoring_function_->getLigandCenter();
for (AtomIterator it = ligand_->beginAtom(); it != ligand_->endAtom(); it++)
{
it->setPosition(M*(it->getPosition()-origin)+origin);
}
}
bool compareMolecules(Molecule& mol1, Molecule& mol2)
{
if(mol1.countAtoms()!=mol2.countAtoms())
return false;
if(mol1.countBonds()!=mol2.countBonds())
return false;
AtomIterator ai;
vector<Vector3> pos1;
vector<float> q1;
BALL_FOREACH_ATOM(mol1, ai)
{
pos1.push_back(ai->getPosition());
q1.push_back(ai->getCharge());
}
/*
* Record current positions of all local atoms and lock storage.
*/
void AtomStorage::makeSnapshot()
{
// Precondition
if (!isCartesian()) {
UTIL_THROW("Error: Coordinates not Cartesian in makeSnapshot");
}
AtomIterator iter;
int i = 0;
for (begin(iter); iter.notEnd(); ++iter) {
snapshot_[i] = iter->position();
++i;
}
locked_ = true;
}
void DockingAlgorithm::mapLigandOntoReferenceLigand()
{
if (!scoring_function_)
{
Log.error()<<"Error DockingAlgorithm::mapLigandOntoReferenceLigand() : ScoringFunction not set!"<<endl;
return;
}
AtomContainer* ligand = scoring_function_->getLigand();
if (!ligand)
{
Log.error()<<"Error DockingAlgorithm::mapLigandOntoReferenceLigand() : Ligand not set!"<<endl;
return;
}
if (!reference_ligand_)
{
Log.error()<<"Error DockingAlgorithm::mapLigandOntoReferenceLigand() : Reference ligand not set!"<<endl;
return;
}
Timer timer;
timer.start();
double lower_bound = 2;
double upper_bound = 5;
double tolerance = 1;
Size no_matched_atoms = 0;
double rmsd = 0;
Matrix4x4 T = mapCompounds(*ligand, *reference_ligand_, no_matched_atoms, rmsd, upper_bound, lower_bound, tolerance);
for (AtomIterator it = ligand->beginAtom(); +it; it++)
{
it->setPosition(T*it->getPosition());
}
timer.stop();
Log.level(10)<<"superposing ligand: "<<timer.getClockTime()<<" seconds"<<endl;
}
/*
* Transform all atomic coordinates from generalized to Cartesian.
*/
void AtomStorage::transformGenToCart(const Boundary& boundary)
{
if (isCartesian()) {
UTIL_THROW("Error: Coordinates are Cartesian on entry");
}
Vector r;
if (nAtom()) {
AtomIterator atomIter;
for (begin(atomIter); atomIter.notEnd(); ++atomIter) {
r = atomIter->position();
boundary.transformGenToCart(r, atomIter->position());
}
}
if (nGhost()) {
GhostIterator ghostIter;
for (begin(ghostIter); ghostIter.notEnd(); ++ghostIter) {
r = ghostIter->position();
boundary.transformGenToCart(r, ghostIter->position());
}
}
isCartesian_ = true;
}
/*
* Return max. sq. displacement of local atoms on this node since snapshot.
*/
double AtomStorage::maxSqDisplacement()
{
if (!isCartesian()) {
UTIL_THROW("Error: Coordinates not Cartesian in maxSqDisplacement");
}
if (!locked_) {
UTIL_THROW("Error: AtomStorage not locked in maxSqDisplacement");
}
Vector dr;
double norm;
double max = 0.0;
AtomIterator iter;
int i = 0;
for (begin(iter); iter.notEnd(); ++iter) {
dr.subtract(iter->position(), snapshot_[i]);
norm = dr.square();
if (norm > max) {
max = norm;
}
++i;
}
return max;
}
/*
* First half of two-step velocity-Verlet integrator.
*/
void NphIntegrator::integrateStep1()
{
Vector dv;
AtomIterator atomIter;
Simulation& sys = simulation();
sys.computeVirialStress();
sys.computeKineticStress();
sys.computeKineticEnergy();
if (sys.domain().isMaster()) {
P_target_ = simulation().boundaryEnsemble().pressure();
T_kinetic_ = sys.kineticEnergy()*2.0/ndof_;
Tensor stress = sys.virialStress();
stress += sys.kineticStress();
P_curr_diag_ = Vector(stress(0, 0), stress(1,1), stress(2,2));
double P_curr = (1.0/3.0)*stress.trace();
double mtk_term = (1.0/2.0)*dt_*T_kinetic_/W_;
// Advance barostat
double V = sys.boundary().volume();
if (mode_ == Cubic) {
nu_[0] += (1.0/2.0)*dt_*V/W_*(P_curr - P_target_) + mtk_term;
nu_[1] = nu_[2] = nu_[0];
} else if (mode_ == Tetragonal) {
nu_[0] += (1.0/2.0)*dt_*V/W_*(P_curr_diag_[0] - P_target_) + mtk_term;
nu_[1] += (1.0/2.0)*dt_*V/W_*((1.0/2.0)*(P_curr_diag_[1]+P_curr_diag_[2]) - P_target_) + mtk_term;
nu_[2] = nu_[1];
} else if (mode_ == Orthorhombic) {
nu_[0] += (1.0/2.0)*dt_*V/W_*(P_curr_diag_[0] - P_target_) + mtk_term;
nu_[1] += (1.0/2.0)*dt_*V/W_*(P_curr_diag_[1] - P_target_) + mtk_term;
nu_[2] += (1.0/2.0)*dt_*V/W_*(P_curr_diag_[2] - P_target_) + mtk_term;
}
}
#ifdef UTIL_MPI
bcast(domain().communicator(), nu_,0);
#endif
// Precompute loop invariant quantities
mtk_term_2_ = (nu_[0]+nu_[1]+nu_[2])/ndof_;
Vector v_fac = Vector((1.0/4.0)*(nu_[0]+mtk_term_2_),
(1.0/4.0)*(nu_[1]+mtk_term_2_),
(1.0/4.0)*(nu_[2]+mtk_term_2_));
exp_v_fac_ = Vector(exp(-v_fac[0]*dt_),
exp(-v_fac[1]*dt_),
exp(-v_fac[2]*dt_));
Vector exp_v_fac_2 = Vector(exp(-(2.0*v_fac[0])*dt_),
exp(-(2.0*v_fac[1])*dt_),
exp(-(2.0*v_fac[2])*dt_));
Vector r_fac = Vector((1.0/2.0)*nu_[0],
(1.0/2.0)*nu_[1],
(1.0/2.0)*nu_[2]);
Vector exp_r_fac = Vector(exp(r_fac[0]*dt_),
exp(r_fac[1]*dt_),
exp(r_fac[2]*dt_));
// Coefficients of sinh(x)/x = a_0 + a_2*x^2 + a_4*x^4 + a_6*x^6 + a_8*x^8 + a_10*x^10
const double a[] = {double(1.0), double(1.0/6.0), double(1.0/120.0),
double(1.0/5040.0), double(1.0/362880.0), double(1.0/39916800.0)};
Vector arg_v = Vector(v_fac[0]*dt_, v_fac[1]*dt_, v_fac[2]*dt_);
Vector arg_r = Vector(r_fac[0]*dt_, r_fac[1]*dt_, r_fac[2]*dt_);
sinhx_fac_v_ = Vector(0.0,0.0,0.0);
Vector sinhx_fac_r = Vector(0.0,0.0,0.0);
Vector term_v = Vector(1.0,1.0,1.0);
Vector term_r = Vector(1.0,1.0,1.0);
for (unsigned int i = 0; i < 6; i++) {
sinhx_fac_v_ += Vector(a[0]*term_v[0],
a[1]*term_v[1],
a[2]*term_v[2]);
sinhx_fac_r += Vector(a[0]*term_r[0],
a[1]*term_r[1],
a[2]*term_r[2]);
term_v = Vector(term_v[0] * arg_v[0] * arg_v[0],
term_v[1] * arg_v[1] * arg_v[1],
term_v[2] * arg_v[2] * arg_v[2]);
term_r = Vector(term_r[0] * arg_r[0] * arg_r[0],
term_r[1] * arg_r[1] * arg_r[1],
term_r[2] * arg_r[2] * arg_r[2]);
}
// 1st half of NPH
Vector vtmp;
double prefactor; // = 0.5*dt/mass
atomStorage().begin(atomIter);
for ( ; atomIter.notEnd(); ++atomIter) {
prefactor = prefactors_[atomIter->typeId()];
dv.multiply(atomIter->force(), prefactor);
dv[0] = dv[0] * exp_v_fac_[0]*sinhx_fac_v_[0];
dv[1] = dv[1] * exp_v_fac_[1]*sinhx_fac_v_[1];
dv[2] = dv[2] * exp_v_fac_[2]*sinhx_fac_v_[2];
Vector& v = atomIter->velocity();
v[0] = v[0] * exp_v_fac_2[0] + dv[0];
v[1] = v[1] * exp_v_fac_2[1] + dv[1];
v[2] = v[2] * exp_v_fac_2[2] + dv[2];
vtmp[0] = v[0]*exp_r_fac[0] *sinhx_fac_r[0];
vtmp[1] = v[1]*exp_r_fac[1] *sinhx_fac_r[1];
vtmp[2] = v[2]*exp_r_fac[2] *sinhx_fac_r[2];
Vector& r = atomIter->position();
r[0] = r[0]*exp_r_fac[0]*exp_r_fac[0] + vtmp[0]*dt_;
r[1] = r[1]*exp_r_fac[1]*exp_r_fac[1] + vtmp[1]*dt_;
r[2] = r[2]*exp_r_fac[2]*exp_r_fac[2] + vtmp[2]*dt_;
}
// Advance box lengths
Vector box_len_scale = Vector(exp(nu_[0]*dt_),
exp(nu_[1]*dt_),
exp(nu_[2]*dt_));
Vector L = sys.boundary().lengths();
L[0] *= box_len_scale[0];
L[1] *= box_len_scale[1];
L[2] *= box_len_scale[2];
// Update box lengths
sys.boundary().setOrthorhombic(L);
}
void EditMode::addStructure_()
{
QAction* action = dynamic_cast<QAction*>(sender());
if (action == 0) return;
String name = ascii(action->text());
scene_->deselect();
if (!fragment_db_)
{
fragment_db_ = new FragmentDB("fragments/Editing-Fragments.db");
}
list<AtomContainer*> containers = scene_->getContainers();
if (containers.size() == 0) return;
Residue* residue = fragment_db_->getResidueCopy(name);
if (residue == 0)
{
residue = fragment_db_->getResidueCopy(name + "-Skeleton");
if (residue == 0) return;
}
Vector3 p;
Size nr = 0;
AtomIterator ait = residue->beginAtom();
for (;+ait; ++ait)
{
p += ait->getPosition();
nr++;
}
if (nr == 0)
{
BALLVIEW_DEBUG
delete residue;
return;
}
p /= (float) nr;
QPoint pos = scene_->mapFromGlobal(mouse_pos_new_);
Matrix4x4 m;
Vector3 x = scene_->mapViewportTo3D(pos.x(), pos.y());
TransformationProcessor tf;
Vector3 vv = scene_->getStage()->getCamera().getViewVector();
float l = vv.getLength();
if (!Maths::isZero(l)) vv /= l;
Vector3 axis = Vector3(1,0,0) % vv;
if (axis.getSquareLength() != 0)
{
Angle a = vv.getAngle(Vector3(1,0,0));
m.setRotation(a, axis);
tf.setTransformation(m);
residue->apply(tf);
}
m.setTranslation(x - p);
tf.setTransformation(m);
residue->apply(tf);
AtomContainer* s = *containers.begin();
if (RTTI::isKindOf<System>(*s))
{
System* system = (System*) s;
Molecule* mol = system->getMolecule(0);
if (mol == 0)
{
mol = new Molecule();
system->insert(*mol);
}
s = mol;
}
s->insert(*residue);
scene_->getMainControl()->deselectCompositeRecursive(s, true);
scene_->getMainControl()->selectCompositeRecursive(residue, true);
scene_->getMainControl()->update(*s);
scene_->notify(new NewSelectionMessage);
// setMode(MOVE__MODE);
}
int main(int argc, char** argv)
{
Path path;
String tmp;
String configuration_string = "";
CommandlineParser parpars("SLICK", "scoring protein-carbohydrate interactions", VERSION, String(__DATE__), "Scoring");
parpars.registerFlag("E", "compute only SLICKEnergy");
parpars.registerFlag("S", "compute only SLICKScore");
parpars.registerFlag("u", "unite atoms");
parpars.registerFlag("n", "read radius rules for the nonpolar solvation from FILE");
parpars.registerFlag("N", "scale nonpolar radii by FACTOR");
parpars.registerFlag("log", "write log file");
parpars.registerMandatoryInputFile("rec", "input receptor file");
parpars.registerMandatoryInputFile("lig", "input ligand file");
parpars.registerOptionalInputFile("cr", "charge rules");
parpars.registerOptionalInputFile("pr", "radius rules for the polar solvation");
parpars.registerOptionalInputFile("lj", "use FILE for LJ parameters");
parpars.registerOptionalInputFile("op", "read options from FILE (command line overrides!)");
parpars.registerOptionalIntegerParameter("v", "verbosity to level");
parpars.registerOptionalDoubleParameter("s", "scaling factor for receptor charges");
parpars.registerOptionalDoubleParameter("t", "scaling factor for ligand charges");
parpars.setSupportedFormats("rec","PDB");
parpars.setSupportedFormats("lig","HIN");
parpars.setSupportedFormats("cr","rul");
parpars.setSupportedFormats("pr","rul");
parpars.setSupportedFormats("lj","rul");
parpars.setSupportedFormats("op", "ini");
String man = "This tool calculates the SLICKEnergy / SLICK Score for protein-carbohydrate complexes.";
parpars.setToolManual(man);
parpars.parse(argc, argv);
Options options;
ScoringFunction::getDefaultOptions(options);
unsigned int verbosity = 0;
if (parpars.get("v") != CommandlineParser::NOT_FOUND)
{
verbosity = parpars.get("v").toInt();
options.setInteger("verbosity", verbosity);
}
float receptor_charge_scaling_factor = 1.0f;
if (parpars.get("s") != CommandlineParser::NOT_FOUND)
{
receptor_charge_scaling_factor = parpars.get("s").toFloat();
configuration_string += "scale_receptor_charges " + parpars.get("s") + "\n";
}
float ligand_charge_scaling_factor = 1.0f;
if (parpars.get("t") != CommandlineParser::NOT_FOUND)
{
ligand_charge_scaling_factor = parpars.get("t").toFloat();
configuration_string += "scale_ligand_charges " + parpars.get("t") + "\n";
}
String protein_file_name = parpars.get("rec");
if (protein_file_name == CommandlineParser::NOT_FOUND)
{
Log.error() << "Missing protein file name." << endl;
return 1;
}
configuration_string += "protein_file_name " + protein_file_name + "\n";
String ligand_file_name = parpars.get("lig");
if (ligand_file_name == CommandlineParser::NOT_FOUND)
{
Log.error() << "Missing ligand file name." << endl;
return 1;
}
configuration_string += "ligand_file_name " + ligand_file_name + "\n";
if (verbosity > 0)
{
Log.info() << "Initializing residue checker." << endl;
}
FragmentDB db("fragments/Fragments.db");
ResidueChecker check(db);
time_t rawtime;
time(&rawtime);
String time_string("start: " + String(asctime(localtime(&rawtime))));
// now load the molecules and assign radii and charges depending on
// what the user wants
System system;
PDBFile protein_file(protein_file_name);
protein_file >> system;
protein_file.close();
Molecule* protein = system.getMolecule(0);
if (verbosity > 0)
{
Log.info() << "Normalizing names (protein)." << endl;
}
system.apply(db.normalize_names);
if (verbosity > 0)
{
Log.info() << "Building bonds (protein)." << endl;
}
system.apply(db.build_bonds);
HINFile ligand_hin_file;
ligand_hin_file.open(ligand_file_name);
ligand_hin_file >> system;
ligand_hin_file.close();
Molecule* ligand = system.getMolecule(1);
// Read and apply charge rules
String charge_rule_file_name = parpars.get("cr");
if (charge_rule_file_name == CommandlineParser::NOT_FOUND)
{
charge_rule_file_name = "solvation/PARSE+ions.rul";
}
else
{
configuration_string += "use_charge_rules " + charge_rule_file_name + "\n";
tmp = path.find(charge_rule_file_name);
if (tmp != "")
{
charge_rule_file_name = tmp;
}
if (verbosity > 0)
{
Log.info() << "Using " << charge_rule_file_name << " as charge rule file" << endl;
}
INIFile charge_ini(charge_rule_file_name);
charge_ini.read();
ChargeRuleProcessor charge_rules(charge_ini);
system.apply(charge_rules);
}
// Read and apply polar charge rules
String polar_radius_rule_file_name = parpars.get("pr");
if (polar_radius_rule_file_name == CommandlineParser::NOT_FOUND)
{
polar_radius_rule_file_name = "solvation/PARSE+ions.rul";
}
else
{
configuration_string += "use_polar_radius_rules " + polar_radius_rule_file_name + "\n";
tmp = path.find(polar_radius_rule_file_name);
if (tmp != "")
{
polar_radius_rule_file_name = tmp;
}
if (verbosity > 0)
{
Log.info() << "Using " << polar_radius_rule_file_name << " as polar radius rule file" << endl;
}
INIFile radius_ini(polar_radius_rule_file_name);
radius_ini.read();
RadiusRuleProcessor radius_rules(radius_ini);
system.apply(radius_rules);
}
if (verbosity > 8)
{
Log.info() << "system statistics:" << endl;
Log.info() << "molecules: " << system.countMolecules() << endl;
Log.info() << "proteins: " << system.countProteins() << endl;
Log.info() << "fragments: " << system.countFragments() << endl;
Log.info() << "atoms: " << system.countAtoms() << endl;
}
// check for uassigned type names
AtomIterator it;
int count = 0;
for (it = system.beginAtom(); +it; ++it)
{
count++;
if (it->getElement().getSymbol() == "?")
{
Log.info() << "Got symbol \"?\": " << it->getFullName() << endl;
}
if (it->getCharge() > 8.0)
{
Log.error() << "Mysterious charge: " << it->getCharge() << "\t"
<< it->getFullName() << "\t" << count << "\t" << it->getElement().getSymbol() << endl;
}
}
// scale charges
if (verbosity > 0)
{
Log.info() << "Scaling receptor charges by " << receptor_charge_scaling_factor << endl;
}
if (parpars.has("s"))
{
for (it = protein->beginAtom(); +it; ++it)
{
it->setCharge(it->getCharge() * receptor_charge_scaling_factor);
}
}
if (verbosity > 0)
{
Log.info() << "Scaling ligand charges by " << ligand_charge_scaling_factor << endl;
}
if (parpars.has("t"))
{
for (it = ligand->beginAtom(); +it; ++it)
{
it->setCharge(it->getCharge() * ligand_charge_scaling_factor);
}
}
String options_file_name = parpars.get("op");
if (options_file_name != CommandlineParser::NOT_FOUND)
{
options.readOptionFile(options_file_name);
configuration_string += "read_options_file " + options_file_name;
}
String lj_parameter_file_name = parpars.get("lj");
if (lj_parameter_file_name == CommandlineParser::NOT_FOUND)
{
lj_parameter_file_name = "Amber/amber94gly.ini";
}
else
{
configuration_string = configuration_string + "lj_parameter_file_name " + lj_parameter_file_name;
}
options.set(VanDerWaalsSlick::Option::LENNARD_JONES_FILE, lj_parameter_file_name);
if (parpars.has("u"))
{
options.setBool(PolarSolvation::Option::UNITE_ATOMS, true);
cout << "Uniting atoms." << endl;
configuration_string += "unite_atoms true\n";
}
else
{
options.setBool(PolarSolvation::Option::UNITE_ATOMS, false);
cout << "Not uniting atoms." << endl;
}
String nonpolar_radius_rule_file_name = parpars.get("n");
if (nonpolar_radius_rule_file_name == CommandlineParser::NOT_FOUND)
{
nonpolar_radius_rule_file_name = "solvation/bondi.rul";
}
else
{
cout << "Using " << nonpolar_radius_rule_file_name << " for nonpolar radii" << endl;
configuration_string += "use_nonpolar_radius_rules " + nonpolar_radius_rule_file_name + "\n";
options.setBool(NonpolarSolvation::Option::NONPOLAR_OVERWRITE_RADII, true);
options.set(NonpolarSolvation::Option::NONPOLAR_RADIUS_RULES, nonpolar_radius_rule_file_name);
}
float score = 0.0f;
if (!parpars.has("S"))
{
configuration_string = configuration_string + "calculate_energy\n";
SLICKEnergy slick(*protein, *ligand, options);
score = slick.calculateScore();
cout << endl << "SLICK/energy is " << score << " kJ/mol" << endl;
if (verbosity > 1)
{
cout << endl << "Scores (w/o coefficients)" << endl << endl;
cout << "Hydrogen bonds " << slick.getHydrogenBondScore() << endl;
cout << "CHPI " << slick.getCHPIScore() << endl;
cout << "VanDerWaalsSlick " << slick.getVDWScore() << endl;
cout << "Nonpolar solvation " << slick.getNonpolarSolvationScore() << endl;
cout << "Polar Solvation " << slick.getPolarSolvationScore() << endl;
}
#ifdef OLD_DATAFILE_FORMAT
String dat_file_name;
String component;
File datfile;
component = "SLICKenergy";
dat_file_name = component + ".dat";
datfile.open(dat_file_name, std::ios::out);
datfile << protein_file_name << " " << ligand_file_name << " " << score << " " << component << endl;
datfile.close();
component = "HB";
dat_file_name = component + ".dat";
datfile.open(dat_file_name, std::ios::out);
datfile << protein_file_name << " " << ligand_file_name << " " << slick.getHydrogenBondScore()
<< " " << component << endl;
datfile.close();
component = "CHPISlick";
dat_file_name = component + ".dat";
datfile.open(dat_file_name, std::ios::out);
datfile << protein_file_name << " " << ligand_file_name << " " << slick.getCHPIScore()
<< " " << component << endl;
datfile.close();
component = "VDW5";
dat_file_name = component + ".dat";
datfile.open(dat_file_name, std::ios::out);
datfile << protein_file_name << " " << ligand_file_name << " " << slick.getVDWScore()
<< " " << component << endl;
datfile.close();
component = "NONPOLAR2";
dat_file_name = component + ".dat";
datfile.open(dat_file_name, std::ios::out);
datfile << protein_file_name << " " << ligand_file_name << " " << slick.getNonpolarSolvationScore()
<< " " << component << endl;
datfile.close();
component = "DESOLV4";
dat_file_name = component + ".dat";
datfile.open(dat_file_name, std::ios::out);
datfile << protein_file_name << " " << ligand_file_name << " " << slick.getPolarSolvationScore()
<< " " << component << endl;
datfile.close();
#endif
time(&rawtime);
time_string = time_string + String("stop: " + String(asctime(localtime(&rawtime))));
if (parpars.has("log"))
{
File logfile("SLICKenergy.log", std::ios::out);
logfile << configuration_string << endl;
logfile << time_string << endl;
logfile.close();
}
}
if (!parpars.has("E"))
{
configuration_string = configuration_string + "calculate_score\n";
SLICKScore slick(*protein, *ligand, options);
score = slick.calculateScore();
cout << endl << "SLICK/score is " << score << " (arb. units)" << endl;
if (verbosity > 1)
{
cout << endl << "Scores (w/o coefficients)" << endl << endl;
cout << "Hydrogen bonds " << slick.getHydrogenBondScore() << endl;
cout << "CHPI " << slick.getCHPIScore() << endl;
cout << "VanDerWaalsSlick " << slick.getVDWScore() << endl;
cout << "Electrostatic int. " << slick.getPolarSolvationScore() << endl;
}
#ifdef OLD_DATAFILE_FORMAT
String dat_file_name;
String component;
File datfile;
component = "SLICKenergy";
dat_file_name = component + ".dat";
datfile.open(dat_file_name, std::ios::out);
datfile << protein_file_name << " " << ligand_file_name << " " << score << " " << component << endl;
datfile.close();
component = "HB";
dat_file_name = component + ".dat";
datfile.open(dat_file_name, std::ios::out);
datfile << protein_file_name << " " << ligand_file_name << " " << slick.getHydrogenBondScore() << " " << component << endl;
datfile.close();
component = "CHPISlick";
dat_file_name = component + ".dat";
datfile.open(dat_file_name, std::ios::out);
datfile << protein_file_name << " " << ligand_file_name << " " << slick.getCHPIScore() << " " << component << endl;
datfile.close();
component = "VDW5";
dat_file_name = component + ".dat";
datfile.open(dat_file_name, std::ios::out);
datfile << protein_file_name << " " << ligand_file_name << " " << slick.getVDWScore() << " " << component << endl;
datfile.close();
component = "COULOMB";
dat_file_name = component + ".dat";
datfile.open(dat_file_name, std::ios::out);
datfile << protein_file_name << " " << ligand_file_name << " " << slick.getPolarSolvationScore() << " " << component << endl;
datfile.close();
#endif
time(&rawtime);
time_string = time_string + String("stop: " + String(asctime(localtime(&rawtime))));
if (parpars.has("log"))
{
File logfile("SLICKscore.log", std::ios::out);
logfile << configuration_string << endl;
logfile << time_string << endl;
logfile.close();
}
}
}
void PeptideCapProcessor::optimizeCapPosition(Chain& chain, bool start)
{
Vector3 translation;
Atom* axis = NULL;
Residue* cap = NULL;
std::vector<Atom*> a;
std::vector<Atom*> b;
Size nr = chain.countResidues();
// cap at the beginning of a peptide
if (start)
{
// put ACE-C to the center
for (AtomIterator it = chain.getResidue(1)->beginAtom(); +it; ++it)
{
if (it->getName() == "N")
{
translation = it->getPosition();
}
b.push_back(&*it);
}
cap = chain.getResidue(0);
for (AtomIterator it = cap->beginAtom(); +it; ++it)
{
a.push_back(&*it);
if (it->getName() == "C")
{
axis = &*it;
}
}
}
//cap at the end of a peptide
else
{
for (AtomIterator it = chain.getResidue(nr-2)->beginAtom(); +it; ++it)
{
if (it->getName() == "C")
{
translation = it->getPosition();
}
b.push_back(&*it);
}
cap = chain.getResidue(nr-1);
for (AtomIterator it = cap->beginAtom(); +it; ++it)
{
a.push_back(&*it);
if (it->getName() == "N")
{
axis = &*it;
}
}
}
//translate the anchor to origin
TranslationProcessor tlp;
tlp.setTranslation(translation*-1.0);
chain.apply(tlp);
//try all torsions
float largest_distance = 0.0;
float tmp_distance = 0.0;
float torsion = 0.0;
float step = 2.0;
TransformationProcessor tfp;
Matrix4x4 m;
m.setRotation( Angle(step, false), axis->getPosition());
tfp.setTransformation(m);
for (Position r = step; r <= 360; r+=step)
{
cap->apply(tfp);
tmp_distance = computeDistance(a,b);
if (largest_distance < tmp_distance)
{
largest_distance = tmp_distance;
torsion = r;
}
}
//apply best rotation angle
m.setRotation( Angle(torsion, false), axis->getPosition());
tfp.setTransformation(m);
cap->apply(tfp);
//now translate the protein back
tlp.setTranslation(translation);
chain.apply(tlp);
}
double Polarity::updateScore()
{
score_ = 0.0;
//float val = 0.0;
//float distance;
//float R1;
//float R2;
const HashGrid3<Atom*>* hashgrid = scoring_function_->getHashGrid();
int radius = 1;
Size no_neighbor_cells = (Size)pow((double)(radius*2+1), 3); // radius of 1 cell == > 3 cells on each axis
double total_sum = 0;
AtomPairVector::const_iterator it;
for (AtomIterator it = scoring_function_->getLigand()->beginAtom(); +it; it++)
{
int no_positive_contacts = 0;
int no_negative_contacts = 0;
bool ligandatom_is_lipophilic = isLipophilic_(&*it);
if (!ligandatom_is_lipophilic)
{
continue;
}
const HashGridBox3<Atom*>* box = hashgrid->getBox(it->getPosition());
// ligand atom lies outside of grid
if (!box) continue;
Position pos_x, pos_y, pos_z;
hashgrid->getIndices(*box, pos_x, pos_y, pos_z);
// indices in HashGrid, where the search for interacting target atoms should begin ( != position of ligand atom)
int i = ((int)pos_x)-radius; if (i < 0){i = 0; }
int j0 = ((int)pos_y)-radius; if (j0 < 0){j0 = 0; }
int k0 = ((int)pos_z)-radius; if (k0 < 0){k0 = 0; }
int x_size = (int)hashgrid->getSizeX();
int y_size = (int)hashgrid->getSizeY();
int z_size = (int)hashgrid->getSizeZ();
for (; i <= pos_x+radius && i < x_size; i++)
{
for (int j = j0; j <= pos_y+radius && j < y_size; j++)
{
for (int k = k0; k <= pos_z+radius && k < z_size; k++)
{
const HashGridBox3<Atom*>* box = hashgrid->getBox(i, j, k);
if (!box->isEmpty())
{
double cell_score = 0;
for (HashGridBox3 < Atom* > ::ConstDataIterator d_it = box->beginData(); d_it != box->endData(); d_it++)
{
if (isBackboneAtom_(*d_it)) continue;
bool rec_polar = isPolar_(*d_it);
bool rec_lipophilic = 0;
if (!rec_polar) rec_lipophilic = isLipophilic_(*d_it);
if (!rec_polar && ! rec_lipophilic) continue;
double distance = ((*d_it)->getPosition()-it->getPosition()).getLength();
if (distance > (*d_it)->getElement().getVanDerWaalsRadius()+it->getElement().getVanDerWaalsRadius()+1.5) continue;
double val;
if (distance > 1) val = 1/distance;
else val = 1;
// lipophilic--lipophilic interaction; else polar rec. -- lipophilic ligand atom
if (rec_lipophilic)
{
val *= -1;
}
cell_score += val;
total_sum += val;
if (scoring_function_->storeInteractionsEnabled())
{
val = scaleScore(val);
it->addInteraction(*d_it, "pol", val);
(*d_it)->addInteraction(&*it, "pol", val);
}
}
if (cell_score < -0.1) no_positive_contacts++;
else if (cell_score > 0.1) no_negative_contacts++;
}
// if there is no neighboring receptor atom, there will be water ...
// else if(i!=pos_x||j!=pos_y||k!=pos_z)
// {
// if(ligandatom_is_lipophilic)
// {
// no_negative_contacts++;
// double scaled_atom_score = 1.0/no_neighbor_cells;
// scaleScore(scaled_atom_score);
// total_sum += scaled_atom_score;
// it->addInteraction("pol",scaled_atom_score);
// }
// }
}
}
}
score_ += (no_negative_contacts-no_positive_contacts)/((double)no_neighbor_cells);
//cout<<it->getFullName()<<" : "<<no_negative_contacts<<", "<<no_positive_contacts<<" "<<(no_negative_contacts-no_positive_contacts)/((double)no_neighbor_cells)<<endl;
}
// scaleScore();
// cout<<"polarity: total sum="<<total_sum<<endl;
// cout<<"polarity: score="<<score_<<endl;
// return score_;
return getScaledScore();
}
void GAMESSLogFile::clearBonds()
{
AtomIterator ai;
for (ai = molecule_->beginAtom(); +ai; ++ai)
ai->destroyBonds();
}
/// Increment Structure Factor
void AsymmSF::sample(long iStep)
{
if (isAtInterval(iStep)) {
Vector position;
std::complex<double> expFactor;
double product;
AtomIterator atomIter;
int i, j, typeId;
makeWaveVectors();
// Set all Fourier modes to zero
for (i = 0; i < nWave_; ++i) {
for (j = 0; j < nMode_; ++j) {
fourierModes_(i, j) = std::complex<double>(0.0, 0.0);
}
}
simulation().atomStorage().begin(atomIter);
for ( ; atomIter.notEnd(); ++atomIter) {
position = atomIter->position();
typeId = atomIter->typeId();
// Loop over wavevectors
for (i = 0; i < nWave_; ++i) {
product = position.dot(waveVectors_[i]);
expFactor = exp( product*Constants::Im );
for (j = 0; j < nMode_; ++j) {
fourierModes_(i, j) += modes_(j, typeId)*expFactor;
}
}
}
for (i = 0; i < nWave_; ++i) {
for (j = 0; j < nMode_; ++j) {
totalFourierModes_(i, j) = std::complex<double>(0.0, 0.0);
}
}
#ifdef UTIL_MPI
// Loop over wavevectors
for (int i = 0; i < nWave_; ++i) {
for (int j = 0; j < nMode_; ++j) {
//Sum values from all processors.
simulation().domain().communicator().Reduce(&fourierModes_(i, j), &totalFourierModes_(i, j), 1,
MPI::DOUBLE_COMPLEX, MPI::SUM, 0);
}
}
#else
for (int i = 0; i < nWave_; ++i) {
for (int j = 0; j < nMode_; ++j) {
totalFourierModes_(i, j) = fourierModes_(i, j);
}
}
#endif
if (simulation().domain().isMaster()) {
// Increment structure factors
double volume = simulation().boundary().volume();
double norm;
for (j = 0; j < nMode_; ++j) {
double maxValue = 0.0;
IntVector maxIntVector;
double maxQ;
for (i = 1; i < nWave_; ++i) {
norm = std::norm(totalFourierModes_(i, j));
if ( double(norm/volume) >= maxValue ) {
maxValue = double(norm/volume);
maxIntVector = waveIntVectors_[i];
maxQ = waveVectors_[i].abs();
}
structureFactors_(i, j) += norm/volume;
}
maximumValue_[j].insert(maximumValue_[j].end(), 1, maxValue);
maximumWaveIntVector_[j].insert(maximumWaveIntVector_[j].end(), 1, maxIntVector);
maximumQ_[j].insert(maximumQ_[j].end(), 1, maxQ);
}
}
++nSample_;
}
}
CHECK(AntechamberFile::AntechamberFile(const String& filename, File::OpenMode open_mode)) // checking for default mode: reading AntechamberFile f(BALL_TEST_DATA_PATH(AntechamberFile_test1.ac)); TEST_EQUAL(f.isValid(), true) RESULT CHECK(AntechamberFile::read(System& system)) AntechamberFile f(BALL_TEST_DATA_PATH(AntechamberFile_test2.ac)); System S; f.read(S); f.close(); TEST_EQUAL(S.countAtoms(), 2) AtomIterator it = S.beginAtom(); TEST_EQUAL(it->getElement().getSymbol(), "H") TEST_REAL_EQUAL(it->getPosition().x, 0.0) TEST_REAL_EQUAL(it->getPosition().y, 1.0) TEST_REAL_EQUAL(it->getPosition().z, 2.0) it++; TEST_EQUAL(it->getElement().getSymbol(), "O") TEST_REAL_EQUAL(it->getPosition().x, 3.0) TEST_REAL_EQUAL(it->getPosition().y, 4.0) TEST_REAL_EQUAL(it->getPosition().z, 5.0) RESULT CHECK(AntechamberFile::read(System& system)) AntechamberFile f(BALL_TEST_DATA_PATH(AntechamberFile_test1.ac)); System S;
/*
* Second half of two-step velocity-Verlet integrator.
*/
void NphIntegrator::integrateStep2()
{
Vector dv;
double prefactor; // = 0.5*dt/mass
AtomIterator atomIter;
Vector v_fac_2 = Vector((1.0/2.0)*(nu_[0]+mtk_term_2_),
(1.0/2.0)*(nu_[1]+mtk_term_2_),
(1.0/2.0)*(nu_[2]+mtk_term_2_));
Vector exp_v_fac_2 = Vector(exp(-v_fac_2[0]*dt_),
exp(-v_fac_2[1]*dt_),
exp(-v_fac_2[2]*dt_));
// 2nd half of NPH
atomStorage().begin(atomIter);
for ( ; atomIter.notEnd(); ++atomIter) {
prefactor = prefactors_[atomIter->typeId()];
dv.multiply(atomIter->force(), prefactor);
dv[0] = dv[0] * exp_v_fac_[0]*sinhx_fac_v_[0];
dv[1] = dv[1] * exp_v_fac_[1]*sinhx_fac_v_[1];
dv[2] = dv[2] * exp_v_fac_[2]*sinhx_fac_v_[2];
Vector& v = atomIter->velocity();
v[0] = v[0] * exp_v_fac_2[0] + dv[0];
v[1] = v[1] * exp_v_fac_2[1] + dv[1];
v[2] = v[2] * exp_v_fac_2[2] + dv[2];
}
Simulation& sys = simulation();
sys.velocitySignal().notify();
sys.computeKineticStress();
sys.computeKineticEnergy();
sys.computeVirialStress();
// Advance barostat
if (sys.domain().isMaster()) {
T_kinetic_ = sys.kineticEnergy()*2.0/ndof_;
Tensor stress = sys.virialStress();
stress += sys.kineticStress();
P_curr_diag_ = Vector(stress(0,0), stress(1,1), stress(2,2));
double P_curr = (1.0/3.0)*stress.trace();
double mtk_term = (1.0/2.0)*dt_*T_kinetic_/W_;
double V = sys.boundary().volume();
if (mode_ == Cubic) {
nu_[0] += (1.0/2.0)*dt_*V/W_*(P_curr - P_target_) + mtk_term;
nu_[1] = nu_[2] = nu_[0];
} else if (mode_ == Tetragonal) {
nu_[0] += (1.0/2.0)*dt_*V/W_*(P_curr_diag_[0] - P_target_) + mtk_term;
nu_[1] += (1.0/2.0)*dt_*V/W_*((1.0/2.0)*(P_curr_diag_[1]+P_curr_diag_[2]) - P_target_) + mtk_term;
nu_[2] = nu_[1];
} else if (mode_ == Orthorhombic) {
nu_[0] += (1.0/2.0)*dt_*V/W_*(P_curr_diag_[0] - P_target_) + mtk_term;
nu_[1] += (1.0/2.0)*dt_*V/W_*(P_curr_diag_[1] - P_target_) + mtk_term;
nu_[2] += (1.0/2.0)*dt_*V/W_*(P_curr_diag_[2] - P_target_) + mtk_term;
}
}
#if 0
// output conserved quantity
sys.computePotentialEnergies();
if (sys.domain().isMaster()) {
std::ofstream file;
file.open("NPH.log", std::ios::out | std::ios::app);
double V = sys.boundary().volume();
double barostat_energy = W_*(nu_[0]*nu_[0]+ nu_[1]*nu_[1] + nu_[2]*nu_[2]);
double pe = sys.potentialEnergy();
double ke = sys.kineticEnergy();
file << Dbl(V,20)
<< Dbl(pe,20)
<< Dbl(ke,20)
<< Dbl(barostat_energy,20)
<< std::endl;
file.close();
}
#endif
#ifdef UTIL_MPI
bcast(domain().communicator(), nu_,0);
#endif
}
// optimal values and old values comared: CHECK(test 1.1: Stretches) HINFile f(BALL_TEST_DATA_PATH(MMFF94_test1.hin)); System s; f >> s; f.close(); TEST_EQUAL(s.countAtoms(), 2) mmff.setup(s); mmff.updateEnergy(); sb.updateStretchForces(); PRECISION(1e-11) // atoms in optimal distance -> forces should be (almost) zero AtomIterator it = s.beginAtom(); TEST_REAL_EQUAL(it->getForce().getDistance(Vector3(0.)), 0) it->setForce(Vector3(0.)); it++; TEST_REAL_EQUAL(it->getForce().getDistance(Vector3(0.)), 0) it->setForce(Vector3(0.)); // move atom by 0.5 to far away it->setPosition(Vector3(2.646,0,0)); mmff.updateEnergy(); sb.updateStretchForces(); it = s.beginAtom(); TEST_REAL_EQUAL(it->getForce().getDistance(Vector3(406.1635825 * FORCES_FACTOR, 0, 0)), 0) it++; TEST_REAL_EQUAL(it->getForce().getDistance(-Vector3(406.1635825 * FORCES_FACTOR, 0, 0)), 0)
