applications/staticProps/HBondGeometric.cpp

/*
 * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
 *
 * The University of Notre Dame grants you ("Licensee") a
 * non-exclusive, royalty free, license to use, modify and
 * redistribute this software in source and binary code form, provided
 * that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the
 *    distribution.
 *
 * This software is provided "AS IS," without a warranty of any
 * kind. All express or implied conditions, representations and
 * warranties, including any implied warranty of merchantability,
 * fitness for a particular purpose or non-infringement, are hereby
 * excluded.  The University of Notre Dame and its licensors shall not
 * be liable for any damages suffered by licensee as a result of
 * using, modifying or distributing the software or its
 * derivatives. In no event will the University of Notre Dame or its
 * licensors be liable for any lost revenue, profit or data, or for
 * direct, indirect, special, consequential, incidental or punitive
 * damages, however caused and regardless of the theory of liability,
 * arising out of the use of or inability to use software, even if the
 * University of Notre Dame has been advised of the possibility of
 * such damages.
 *
 * SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
 * research, please cite the appropriate papers when you publish your
 * work.  Good starting points are:
 *                                                                      
 * [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).             
 * [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).          
 * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 234107 (2008).          
 * [4] Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
 * [4] , Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011). 
 */
 
#include "applications/staticProps/HBondGeometric.hpp"
#include "utils/simError.h"
#include "io/DumpReader.hpp"
#include "primitives/Molecule.hpp"
#include "utils/NumericConstant.hpp"

#include <vector>

namespace OpenMD {

  HBondGeometric::HBondGeometric(SimInfo* info, 
                                 const std::string& filename, 
                                 const std::string& sele1,
                                 const std::string& sele2,
                                 double rCut, double thetaCut, int nbins) :
    StaticAnalyser(info, filename),
    selectionScript1_(sele1), seleMan1_(info), evaluator1_(info),
    selectionScript2_(sele2), seleMan2_(info), evaluator2_(info) {
    
    setOutputName(getPrefix(filename) + ".hbg");

    ff_ = info_->getForceField();

    evaluator1_.loadScriptString(sele1);
    if (!evaluator1_.isDynamic()) {
      seleMan1_.setSelectionSet(evaluator1_.evaluate());
    }
    evaluator2_.loadScriptString(sele2);
    if (!evaluator2_.isDynamic()) {
      seleMan2_.setSelectionSet(evaluator2_.evaluate());
    }

    // Set up cutoff values:

    rCut_ = rCut;
    thetaCut_ = thetaCut;
    nBins_ = nbins;

    nHBonds_.resize(nBins_);
    nDonor_.resize(nBins_);
    nAcceptor_.resize(nBins_);

    initializeHistogram();
  }

  HBondGeometric::~HBondGeometric() {
    nHBonds_.clear();
    nDonor_.clear();
    nAcceptor_.clear(); 
  }
  
  void HBondGeometric::initializeHistogram() {
    std::fill(nHBonds_.begin(),   nHBonds_.end(),   0);
    std::fill(nDonor_.begin(),    nDonor_.end(),    0);
    std::fill(nAcceptor_.begin(), nAcceptor_.end(), 0);
    nSelected_ = 0;
  }
  
  void HBondGeometric::process() {
    Molecule* mol1;
    Molecule* mol2;
    RigidBody* rb1;
    Molecule::HBondDonor* hbd1;
    Molecule::HBondDonor* hbd2;
    std::vector<Molecule::HBondDonor*>::iterator hbdi;
    std::vector<Molecule::HBondDonor*>::iterator hbdj;
    std::vector<Atom*>::iterator hbai;
    std::vector<Atom*>::iterator hbaj;
    Atom* hba1;
    Atom* hba2;
    SimInfo::MoleculeIterator mi;
    Molecule::RigidBodyIterator rbIter;
    Molecule::IntegrableObjectIterator ioi;
    Vector3d dPos;
    Vector3d aPos;
    Vector3d hPos;
    Vector3d DH;
    Vector3d DA;
    RealType DAdist, DHdist, theta, ctheta;
    int ii, jj;
    int nHB, nA, nD;

    DumpReader reader(info_, dumpFilename_);    
    int nFrames = reader.getNFrames();
    frameCounter_ = 0;

    for (int istep = 0; istep < nFrames; istep += step_) {
      reader.readFrame(istep);
      frameCounter_++;
      currentSnapshot_ = info_->getSnapshotManager()->getCurrentSnapshot();
     
      // update the positions of atoms which belong to the rigidbodies
      
      for (mol1 = info_->beginMolecule(mi); mol1 != NULL; 
           mol1 = info_->nextMolecule(mi)) {
        for (rb1 = mol1->beginRigidBody(rbIter); rb1 != NULL; 
             rb1 = mol1->nextRigidBody(rbIter)) {
          rb1->updateAtoms();
        }        
      }           
      
      if  (evaluator1_.isDynamic()) {
        seleMan1_.setSelectionSet(evaluator1_.evaluate());
      }
      if  (evaluator2_.isDynamic()) {
        seleMan2_.setSelectionSet(evaluator2_.evaluate());
      }
      
      for (mol1 = seleMan1_.beginSelectedMolecule(ii);
           mol1 != NULL; mol1 = seleMan1_.nextSelectedMolecule(ii)) {

        // We're collecting statistics on the molecules in selection 1:
        nHB = 0;
        nA = 0;
        nD = 0;
        
        for (mol2 = seleMan2_.beginSelectedMolecule(jj);
             mol2 != NULL; mol2 = seleMan2_.nextSelectedMolecule(jj)) {
          
          // loop over the possible donors in molecule 1:
          for (hbd1 = mol1->beginHBondDonor(hbdi); hbd1 != NULL;
               hbd1 = mol1->nextHBondDonor(hbdi)) {
            dPos = hbd1->donorAtom->getPos();
            hPos = hbd1->donatedHydrogen->getPos();
            DH = hPos - dPos; 
            currentSnapshot_->wrapVector(DH);
            DHdist = DH.length();

            // loop over the possible acceptors in molecule 2:
            for (hba2 = mol2->beginHBondAcceptor(hbaj); hba2 != NULL;
                 hba2 = mol2->nextHBondAcceptor(hbaj)) {
              aPos = hba2->getPos();
              DA = aPos - dPos;              
              currentSnapshot_->wrapVector(DA);
              DAdist = DA.length();

              // Distance criteria: are the donor and acceptor atoms
              // close enough?
              if (DAdist < rCut_) {

                ctheta = dot(DH, DA) / (DHdist * DAdist);
                theta = acos(ctheta) * 180.0 / M_PI;

                // Angle criteria: are the D-H and D-A and vectors close?
                if (theta < thetaCut_) {
                  // molecule 1 is a Hbond donor:
                  nHB++;
                  nD++;
                }
              }            
            }            
          }

          // now loop over the possible acceptors in molecule 1:
          for (hba1 = mol1->beginHBondAcceptor(hbai); hba1 != NULL;
               hba1 = mol1->nextHBondAcceptor(hbai)) {
            aPos = hba1->getPos();
            
            // loop over the possible donors in molecule 2:
            for (hbd2 = mol2->beginHBondDonor(hbdj); hbd2 != NULL;
               hbd2 = mol2->nextHBondDonor(hbdj)) {
              dPos = hbd2->donorAtom->getPos();

              DA = aPos - dPos;
              currentSnapshot_->wrapVector(DA);
              DAdist = DA.length();
              
              // Distance criteria: are the donor and acceptor atoms
              // close enough?
              if (DAdist < rCut_) {
                hPos = hbd2->donatedHydrogen->getPos();
                DH = hPos - dPos; 
                currentSnapshot_->wrapVector(DH);
                DHdist = DH.length();
                ctheta = dot(DH, DA) / (DHdist * DAdist);
                theta = acos(ctheta) * 180.0 / M_PI;
                // Angle criteria: are the D-H and D-A and vectors close?
                if (theta < thetaCut_) {
                  // molecule 1 is a Hbond acceptor:
                  nHB++;
                  nA++;
                }                
              }
            }
          }
        }                 
        collectHistogram(nHB, nA, nD);
      }
    }
    writeHistogram();
  }
 
        
  void HBondGeometric::collectHistogram(int nHB, int nA, int nD) {
    nHBonds_[nHB] += 1;
    nAcceptor_[nA] += 1;
    nDonor_[nD] += 1;
    nSelected_++;
  }


  void HBondGeometric::writeHistogram() {
        
    std::ofstream osq(getOutputFileName().c_str());

    if (osq.is_open()) {
      
      osq << "# HydrogenBonding Statistics\n";
      osq << "# selection1: (" << selectionScript1_ << ")"
          << "\tselection2: (" << selectionScript2_ <<  ")\n";
      osq << "# molecules in selection1: " << nSelected_ << "\n";
      osq << "# nHBonds\tnAcceptor\tnDonor\tp(nHBonds)\tp(nAcceptor)\tp(nDonor)\n";
      // Normalize by number of frames and write it out:
      for (int i = 0; i < nBins_; ++i) {
        osq << i;
        osq << "\t" << nHBonds_[i];
        osq << "\t" << nAcceptor_[i];
        osq << "\t" << nDonor_[i];
        osq << "\t" << (RealType) (nHBonds_[i]) / nSelected_;
        osq << "\t" << (RealType) (nAcceptor_[i]) / nSelected_;
        osq << "\t" << (RealType) (nDonor_[i]) / nSelected_;
        osq << "\n";
      }
      osq.close();
      
    } else {
      sprintf(painCave.errMsg, "HBondGeometric: unable to open %s\n", 
              (getOutputFileName() + "q").c_str());
      painCave.isFatal = 1;
      simError();  
    }
  }
}

      
Revision:	2071
Committed:	Sat Mar 7 21:41:51 2015 UTC (10 years, 7 months ago) by gezelter
File size:	9780 byte(s)
Log Message:	Reducing the number of warnings when using g++ to compile.
#	User	Rev	Content
1	gezelter	2049	/*
2			* Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3			*
4			* The University of Notre Dame grants you ("Licensee") a
5			* non-exclusive, royalty free, license to use, modify and
6			* redistribute this software in source and binary code form, provided
7			* that the following conditions are met:
8			*
9			* 1. Redistributions of source code must retain the above copyright
10			* notice, this list of conditions and the following disclaimer.
11			*
12			* 2. Redistributions in binary form must reproduce the above copyright
13			* notice, this list of conditions and the following disclaimer in the
14			* documentation and/or other materials provided with the
15			* distribution.
16			*
17			* This software is provided "AS IS," without a warranty of any
18			* kind. All express or implied conditions, representations and
19			* warranties, including any implied warranty of merchantability,
20			* fitness for a particular purpose or non-infringement, are hereby
21			* excluded. The University of Notre Dame and its licensors shall not
22			* be liable for any damages suffered by licensee as a result of
23			* using, modifying or distributing the software or its
24			* derivatives. In no event will the University of Notre Dame or its
25			* licensors be liable for any lost revenue, profit or data, or for
26			* direct, indirect, special, consequential, incidental or punitive
27			* damages, however caused and regardless of the theory of liability,
28			* arising out of the use of or inability to use software, even if the
29			* University of Notre Dame has been advised of the possibility of
30			* such damages.
31			*
32			* SUPPORT OPEN SCIENCE! If you use OpenMD or its source code in your
33			* research, please cite the appropriate papers when you publish your
34			* work. Good starting points are:
35			*
36			* [1] Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).
37			* [2] Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).
38			* [3] Sun, Lin & Gezelter, J. Chem. Phys. 128, 234107 (2008).
39			* [4] Kuang & Gezelter, J. Chem. Phys. 133, 164101 (2010).
40			* [4] , Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
41			*/
42
43			#include "applications/staticProps/HBondGeometric.hpp"
44			#include "utils/simError.h"
45			#include "io/DumpReader.hpp"
46			#include "primitives/Molecule.hpp"
47			#include "utils/NumericConstant.hpp"
48
49			#include <vector>
50
51			namespace OpenMD {
52
53			HBondGeometric::HBondGeometric(SimInfo* info,
54			const std::string& filename,
55			const std::string& sele1,
56			const std::string& sele2,
57			double rCut, double thetaCut, int nbins) :
58			StaticAnalyser(info, filename),
59	gezelter	2071	selectionScript1_(sele1), seleMan1_(info), evaluator1_(info),
60			selectionScript2_(sele2), seleMan2_(info), evaluator2_(info) {
61	gezelter	2049
62			setOutputName(getPrefix(filename) + ".hbg");
63
64			ff_ = info_->getForceField();
65
66			evaluator1_.loadScriptString(sele1);
67			if (!evaluator1_.isDynamic()) {
68			seleMan1_.setSelectionSet(evaluator1_.evaluate());
69			}
70			evaluator2_.loadScriptString(sele2);
71			if (!evaluator2_.isDynamic()) {
72			seleMan2_.setSelectionSet(evaluator2_.evaluate());
73			}
74
75			// Set up cutoff values:
76
77			rCut_ = rCut;
78			thetaCut_ = thetaCut;
79			nBins_ = nbins;
80
81			nHBonds_.resize(nBins_);
82			nDonor_.resize(nBins_);
83			nAcceptor_.resize(nBins_);
84	gezelter	2050
85			initializeHistogram();
86	gezelter	2049	}
87
88			HBondGeometric::~HBondGeometric() {
89			nHBonds_.clear();
90			nDonor_.clear();
91			nAcceptor_.clear();
92			}
93
94			void HBondGeometric::initializeHistogram() {
95			std::fill(nHBonds_.begin(), nHBonds_.end(), 0);
96			std::fill(nDonor_.begin(), nDonor_.end(), 0);
97			std::fill(nAcceptor_.begin(), nAcceptor_.end(), 0);
98			nSelected_ = 0;
99			}
100
101			void HBondGeometric::process() {
102	gezelter	2052	Molecule* mol1;
103			Molecule* mol2;
104	gezelter	2049	RigidBody* rb1;
105	gezelter	2052	Molecule::HBondDonor* hbd1;
106			Molecule::HBondDonor* hbd2;
107			std::vector<Molecule::HBondDonor*>::iterator hbdi;
108			std::vector<Molecule::HBondDonor*>::iterator hbdj;
109			std::vector<Atom*>::iterator hbai;
110			std::vector<Atom*>::iterator hbaj;
111			Atom* hba1;
112			Atom* hba2;
113	gezelter	2049	SimInfo::MoleculeIterator mi;
114			Molecule::RigidBodyIterator rbIter;
115			Molecule::IntegrableObjectIterator ioi;
116	gezelter	2052	Vector3d dPos;
117			Vector3d aPos;
118			Vector3d hPos;
119			Vector3d DH;
120			Vector3d DA;
121			RealType DAdist, DHdist, theta, ctheta;
122	gezelter	2049	int ii, jj;
123			int nHB, nA, nD;
124
125			DumpReader reader(info_, dumpFilename_);
126			int nFrames = reader.getNFrames();
127			frameCounter_ = 0;
128
129			for (int istep = 0; istep < nFrames; istep += step_) {
130			reader.readFrame(istep);
131			frameCounter_++;
132			currentSnapshot_ = info_->getSnapshotManager()->getCurrentSnapshot();
133
134			// update the positions of atoms which belong to the rigidbodies
135
136	gezelter	2052	for (mol1 = info_->beginMolecule(mi); mol1 != NULL;
137			mol1 = info_->nextMolecule(mi)) {
138			for (rb1 = mol1->beginRigidBody(rbIter); rb1 != NULL;
139			rb1 = mol1->nextRigidBody(rbIter)) {
140	gezelter	2049	rb1->updateAtoms();
141			}
142			}
143
144			if (evaluator1_.isDynamic()) {
145			seleMan1_.setSelectionSet(evaluator1_.evaluate());
146			}
147			if (evaluator2_.isDynamic()) {
148			seleMan2_.setSelectionSet(evaluator2_.evaluate());
149			}
150
151	gezelter	2052	for (mol1 = seleMan1_.beginSelectedMolecule(ii);
152			mol1 != NULL; mol1 = seleMan1_.nextSelectedMolecule(ii)) {
153	gezelter	2049
154	gezelter	2052	// We're collecting statistics on the molecules in selection 1:
155	gezelter	2049	nHB = 0;
156			nA = 0;
157			nD = 0;
158
159	gezelter	2052	for (mol2 = seleMan2_.beginSelectedMolecule(jj);
160			mol2 != NULL; mol2 = seleMan2_.nextSelectedMolecule(jj)) {
161
162			// loop over the possible donors in molecule 1:
163			for (hbd1 = mol1->beginHBondDonor(hbdi); hbd1 != NULL;
164			hbd1 = mol1->nextHBondDonor(hbdi)) {
165			dPos = hbd1->donorAtom->getPos();
166			hPos = hbd1->donatedHydrogen->getPos();
167			DH = hPos - dPos;
168			currentSnapshot_->wrapVector(DH);
169			DHdist = DH.length();
170	gezelter	2049
171	gezelter	2052	// loop over the possible acceptors in molecule 2:
172			for (hba2 = mol2->beginHBondAcceptor(hbaj); hba2 != NULL;
173			hba2 = mol2->nextHBondAcceptor(hbaj)) {
174			aPos = hba2->getPos();
175			DA = aPos - dPos;
176			currentSnapshot_->wrapVector(DA);
177			DAdist = DA.length();
178	gezelter	2049
179	gezelter	2052	// Distance criteria: are the donor and acceptor atoms
180			// close enough?
181			if (DAdist < rCut_) {
182
183			ctheta = dot(DH, DA) / (DHdist * DAdist);
184			theta = acos(ctheta) * 180.0 / M_PI;
185
186			// Angle criteria: are the D-H and D-A and vectors close?
187			if (theta < thetaCut_) {
188			// molecule 1 is a Hbond donor:
189			nHB++;
190			nD++;
191	gezelter	2049	}
192	gezelter	2052	}
193			}
194			}
195
196			// now loop over the possible acceptors in molecule 1:
197			for (hba1 = mol1->beginHBondAcceptor(hbai); hba1 != NULL;
198			hba1 = mol1->nextHBondAcceptor(hbai)) {
199			aPos = hba1->getPos();
200	gezelter	2049
201	gezelter	2052	// loop over the possible donors in molecule 2:
202			for (hbd2 = mol2->beginHBondDonor(hbdj); hbd2 != NULL;
203			hbd2 = mol2->nextHBondDonor(hbdj)) {
204			dPos = hbd2->donorAtom->getPos();
205	gezelter	2049
206	gezelter	2052	DA = aPos - dPos;
207			currentSnapshot_->wrapVector(DA);
208			DAdist = DA.length();
209
210			// Distance criteria: are the donor and acceptor atoms
211			// close enough?
212			if (DAdist < rCut_) {
213			hPos = hbd2->donatedHydrogen->getPos();
214			DH = hPos - dPos;
215			currentSnapshot_->wrapVector(DH);
216			DHdist = DH.length();
217			ctheta = dot(DH, DA) / (DHdist * DAdist);
218			theta = acos(ctheta) * 180.0 / M_PI;
219			// Angle criteria: are the D-H and D-A and vectors close?
220			if (theta < thetaCut_) {
221			// molecule 1 is a Hbond acceptor:
222			nHB++;
223			nA++;
224			}
225	gezelter	2049	}
226	gezelter	2052	}
227	gezelter	2049	}
228	gezelter	2052	}
229	gezelter	2049	collectHistogram(nHB, nA, nD);
230			}
231			}
232			writeHistogram();
233			}
234
235
236			void HBondGeometric::collectHistogram(int nHB, int nA, int nD) {
237			nHBonds_[nHB] += 1;
238			nAcceptor_[nA] += 1;
239			nDonor_[nD] += 1;
240			nSelected_++;
241			}
242
243
244			void HBondGeometric::writeHistogram() {
245
246			std::ofstream osq(getOutputFileName().c_str());
247
248			if (osq.is_open()) {
249
250			osq << "# HydrogenBonding Statistics\n";
251			osq << "# selection1: (" << selectionScript1_ << ")"
252			<< "\tselection2: (" << selectionScript2_ << ")\n";
253	gezelter	2052	osq << "# molecules in selection1: " << nSelected_ << "\n";
254			osq << "# nHBonds\tnAcceptor\tnDonor\tp(nHBonds)\tp(nAcceptor)\tp(nDonor)\n";
255	gezelter	2049	// Normalize by number of frames and write it out:
256			for (int i = 0; i < nBins_; ++i) {
257			osq << i;
258	gezelter	2052	osq << "\t" << nHBonds_[i];
259			osq << "\t" << nAcceptor_[i];
260			osq << "\t" << nDonor_[i];
261	gezelter	2049	osq << "\t" << (RealType) (nHBonds_[i]) / nSelected_;
262			osq << "\t" << (RealType) (nAcceptor_[i]) / nSelected_;
263			osq << "\t" << (RealType) (nDonor_[i]) / nSelected_;
264			osq << "\n";
265			}
266			osq.close();
267
268			} else {
269			sprintf(painCave.errMsg, "HBondGeometric: unable to open %s\n",
270			(getOutputFileName() + "q").c_str());
271			painCave.isFatal = 1;
272			simError();
273			}
274			}
275			}
276
277
278
279