src/rnemd/RNEMD.hpp

/*
 * 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, 24107 (2008).          
 * [4]  Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
 * [5]  Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
 */
 
/**
 * @file RNEMD.hpp
 * @author gezelter
 * @date 03/13/2009
 * @time 15:56pm
 * @version 1.0
 */

#ifndef INTEGRATORS_RNEMD_HPP
#define INTEGRATORS_RNEMD_HPP
#include "brains/SimInfo.hpp"
#include "math/RandNumGen.hpp"
#include "selection/SelectionEvaluator.hpp"
#include "selection/SelectionManager.hpp"
#include <iostream>

using namespace std;
namespace OpenMD {

  /**
   * @class RNEMD RNEMD.hpp "integrators/RNEMD.hpp"
   * @todo document
   */
  class RNEMD {
  public:
    RNEMD(SimInfo* info);
    virtual ~RNEMD();
    
    void doRNEMD();
    void doSwap();
    void doScale();
    void doShiftScale();
    void collectData();
    void getStarted();
    void getStatus();
    void set_RNEMD_exchange_time(RealType exchangeTime) {
      exchangeTime_ = exchangeTime;
    }
    void set_RNEMD_nBins(int nbins) { nBins_ = nbins; }
    void set_RNEMD_logWidth(int logWidth) { rnemdLogWidth_ = logWidth; }
    void set_RNEMD_exchange_total(RealType et) { exchangeSum_ = et; }
    void set_RNEMD_target_flux(RealType targetFlux) {targetFlux_ = targetFlux;}
    void set_RNEMD_target_JzKE(RealType targetJzKE) {targetJzKE_ = targetJzKE;}
    void set_RNEMD_target_jzpx(RealType targetJzpx) {targetJzpx_ = targetJzpx;}
    void set_RNEMD_target_jzpy(RealType targetJzpy) {targetJzpy_ = targetJzpy;}
    void set_RNEMD_target_jzpz(RealType targetJzpz) {targetJzpz_ = targetJzpz;}
    void set_RNEMD_target_jzpz2(RealType targetJzpz2) {targetJzpz2_ = targetJzpz2;}
    RealType get_RNEMD_exchange_total() { return exchangeSum_; }

  private:

    enum RNEMDTypeEnum {
      rnemdKineticSwap,
      rnemdKineticScale,
      rnemdKineticScaleVAM,
      rnemdKineticScaleAM,
      rnemdPxScale,
      rnemdPyScale,
      rnemdPzScale,
      rnemdPx,
      rnemdPy,
      rnemdPz,
      rnemdShiftScaleV,
      rnemdShiftScaleVAM,
      rnemdUnknown
    };
    
    SimInfo* info_;
    RandNumGen* randNumGen_;
    map<string, RNEMDTypeEnum> stringToEnumMap_;
    RNEMDTypeEnum rnemdType_;
    string rnemdObjectSelection_;
    SelectionEvaluator evaluator_;
    SelectionManager seleMan_;
    bool usePeriodicBoundaryConditions_;
    bool outputTemp_;
    bool outputVx_;
    bool outputVy_;
    bool output3DTemp_;
    bool outputRotTemp_;
    // James put this in.
    bool outputDen_;
    bool outputVz_;
    int nBins_; /**< The number of bins to divide the simulation box into.  */
    /*!
      The middle bin for the RNEMD method. midBin_ = nBins_/2;
      Depending on the setting of the flux, this box should contain the minimum energy (temperature)
      within the simulation. 
    */
    int midBin_;
    int rnemdLogWidth_; /**< Number of elements to print out in logs */
    RealType zShift_;
    RealType exchangeTime_;
    RealType targetFlux_;
    RealType targetJzKE_;
    RealType targetJzpx_;
    RealType targetJzpy_;
    RealType targetJzpz_;
    RealType targetJzpz2_;
    Vector3d jzp_, njzp_;
    RealType exchangeSum_;
    int failTrialCount_;
    int failRootCount_;
    ofstream rnemdLog_;
    int logFrameCount_;
    // James added denLog, vzzLog
    ofstream tempLog_, vxzLog_, vyzLog_, denLog_, vzzLog_, denLog2_;
    ofstream xTempLog_, yTempLog_, zTempLog_, rotTempLog_;
    // keeps track of what's being averaged James added DenHist, pzzHist
    vector<RealType> tempHist_, pxzHist_, pyzHist_, mHist_, DenHist_, pzzHist_, DenHist2_;
    vector<RealType> xTempHist_, yTempHist_, zTempHist_, rotTempHist_;
    // keeps track of the number of degrees of freedom being averaged
    //vector<int> pxzCount_, pyzCount_;
    vector<int> tempCount_, xyzTempCount_, rotTempCount_;
  };

}
#endif //INTEGRATORS_RNEMD_HPP
Revision:	1728
Committed:	Wed May 30 16:07:03 2012 UTC (12 years, 11 months ago) by jmarr
Original Path:	*branches/development/src/integrators/RNEMD.hpp*
File size:	5830 byte(s)
Log Message:	resolved
#	User	Rev	Content
1	gezelter	1329	/*
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	gezelter	1390	* 1. Redistributions of source code must retain the above copyright
10	gezelter	1329	* notice, this list of conditions and the following disclaimer.
11			*
12	gezelter	1390	* 2. Redistributions in binary form must reproduce the above copyright
13	gezelter	1329	* 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	gezelter	1390	*
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, 24107 (2008).
39	jmarr	1728	* [4] Kuang & Gezelter, J. Chem. Phys. 133, 164101 (2010).
40			* [5] Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
41	gezelter	1329	*/
42
43			/**
44			* @file RNEMD.hpp
45			* @author gezelter
46			* @date 03/13/2009
47			* @time 15:56pm
48			* @version 1.0
49			*/
50
51			#ifndef INTEGRATORS_RNEMD_HPP
52			#define INTEGRATORS_RNEMD_HPP
53			#include "brains/SimInfo.hpp"
54			#include "math/RandNumGen.hpp"
55	gezelter	1331	#include "selection/SelectionEvaluator.hpp"
56			#include "selection/SelectionManager.hpp"
57	skuang	1368	#include <iostream>
58	gezelter	1329
59	gezelter	1629	using namespace std;
60	gezelter	1390	namespace OpenMD {
61	gezelter	1329
62			/**
63			* @class RNEMD RNEMD.hpp "integrators/RNEMD.hpp"
64			* @todo document
65			*/
66			class RNEMD {
67			public:
68			RNEMD(SimInfo* info);
69			virtual ~RNEMD();
70	skuang	1368
71			void doRNEMD();
72	gezelter	1329	void doSwap();
73	skuang	1368	void doScale();
74	gezelter	1722	void doShiftScale();
75	skuang	1368	void collectData();
76			void getStarted();
77	skuang	1338	void getStatus();
78	skuang	1368	void set_RNEMD_exchange_time(RealType exchangeTime) {
79			exchangeTime_ = exchangeTime;
80			}
81	gezelter	1329	void set_RNEMD_nBins(int nbins) { nBins_ = nbins; }
82	gezelter	1629	void set_RNEMD_logWidth(int logWidth) { rnemdLogWidth_ = logWidth; }
83	skuang	1368	void set_RNEMD_exchange_total(RealType et) { exchangeSum_ = et; }
84			void set_RNEMD_target_flux(RealType targetFlux) {targetFlux_ = targetFlux;}
85	gezelter	1722	void set_RNEMD_target_JzKE(RealType targetJzKE) {targetJzKE_ = targetJzKE;}
86			void set_RNEMD_target_jzpx(RealType targetJzpx) {targetJzpx_ = targetJzpx;}
87			void set_RNEMD_target_jzpy(RealType targetJzpy) {targetJzpy_ = targetJzpy;}
88			void set_RNEMD_target_jzpz(RealType targetJzpz) {targetJzpz_ = targetJzpz;}
89	jmarr	1728	void set_RNEMD_target_jzpz2(RealType targetJzpz2) {targetJzpz2_ = targetJzpz2;}
90	gezelter	1629	RealType get_RNEMD_exchange_total() { return exchangeSum_; }
91	gezelter	1331
92	gezelter	1329	private:
93	gezelter	1331
94	gezelter	1329	enum RNEMDTypeEnum {
95	skuang	1368	rnemdKineticSwap,
96			rnemdKineticScale,
97	gezelter	1722	rnemdKineticScaleVAM,
98			rnemdKineticScaleAM,
99	skuang	1368	rnemdPxScale,
100			rnemdPyScale,
101			rnemdPzScale,
102	gezelter	1329	rnemdPx,
103			rnemdPy,
104			rnemdPz,
105	gezelter	1722	rnemdShiftScaleV,
106			rnemdShiftScaleVAM,
107	gezelter	1329	rnemdUnknown
108			};
109	skuang	1368
110	gezelter	1329	SimInfo* info_;
111			RandNumGen* randNumGen_;
112	gezelter	1629	map<string, RNEMDTypeEnum> stringToEnumMap_;
113	gezelter	1329	RNEMDTypeEnum rnemdType_;
114	gezelter	1629	string rnemdObjectSelection_;
115	skuang	1368	SelectionEvaluator evaluator_;
116	gezelter	1331	SelectionManager seleMan_;
117			bool usePeriodicBoundaryConditions_;
118	gezelter	1722	bool outputTemp_;
119			bool outputVx_;
120			bool outputVy_;
121	gezelter	1629	bool output3DTemp_;
122	gezelter	1722	bool outputRotTemp_;
123	jmarr	1728	// James put this in.
124			bool outputDen_;
125			bool outputVz_;
126	gezelter	1629	int nBins_; /*< The number of bins to divide the simulation box into. /
127			/*!
128			The middle bin for the RNEMD method. midBin_ = nBins_/2;
129			Depending on the setting of the flux, this box should contain the minimum energy (temperature)
130			within the simulation.
131			*/
132	skuang	1368	int midBin_;
133	gezelter	1629	int rnemdLogWidth_; /*< Number of elements to print out in logs /
134			RealType zShift_;
135	skuang	1368	RealType exchangeTime_;
136			RealType targetFlux_;
137	gezelter	1722	RealType targetJzKE_;
138			RealType targetJzpx_;
139			RealType targetJzpy_;
140			RealType targetJzpz_;
141	jmarr	1728	RealType targetJzpz2_;
142	gezelter	1722	Vector3d jzp_, njzp_;
143	skuang	1368	RealType exchangeSum_;
144			int failTrialCount_;
145			int failRootCount_;
146	jmarr	1728	ofstream rnemdLog_;
147			int logFrameCount_;
148			// James added denLog, vzzLog
149			ofstream tempLog_, vxzLog_, vyzLog_, denLog_, vzzLog_, denLog2_;
150	gezelter	1722	ofstream xTempLog_, yTempLog_, zTempLog_, rotTempLog_;
151	jmarr	1728	// keeps track of what's being averaged James added DenHist, pzzHist
152			vector<RealType> tempHist_, pxzHist_, pyzHist_, mHist_, DenHist_, pzzHist_, DenHist2_;
153	gezelter	1722	vector<RealType> xTempHist_, yTempHist_, zTempHist_, rotTempHist_;
154	skuang	1368	// keeps track of the number of degrees of freedom being averaged
155	gezelter	1722	//vector<int> pxzCount_, pyzCount_;
156			vector<int> tempCount_, xyzTempCount_, rotTempCount_;
157	gezelter	1329	};
158
159			}
160	skuang	1368	#endif //INTEGRATORS_RNEMD_HPP