ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/src/brains/Stats.cpp
(Generate patch)

Comparing branches/development/src/brains/Stats.cpp (file contents):
Revision 1723 by gezelter, Thu May 24 20:59:54 2012 UTC vs.
Revision 1859 by gezelter, Thu Apr 4 19:42:59 2013 UTC

# Line 35 | Line 35
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).          
38 > * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 234107 (2008).          
39   * [4]  Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
40   * [5]  Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
41   */
# Line 49 | Line 49
49   */
50  
51   #include "brains/Stats.hpp"
52 + #include "brains/Thermo.hpp"
53  
54   namespace OpenMD {
55  
56 <  bool Stats::isInit_ = false;
56 <  std::string Stats::title_[Stats::ENDINDEX - Stats::BEGININDEX];
57 <  std::string Stats::units_[Stats::ENDINDEX - Stats::BEGININDEX];
58 <  Stats::StatsMapType Stats::statsMap;
59 <  Stats::Stats() {
56 >  Stats::Stats(SimInfo* info) : isInit_(false), info_(info) {  
57  
58      if (!isInit_) {
59        init();
60        isInit_ = true;
61      }
65 –
62    }
63  
64    void Stats::init() {
65 +  
66 +    data_.resize(Stats::ENDINDEX);
67  
68 <    Stats::title_[TIME] = "Time";
69 <    Stats::title_[TOTAL_ENERGY] = "Total Energy";
70 <    Stats::title_[POTENTIAL_ENERGY] = "Potential Energy";
71 <    Stats::title_[KINETIC_ENERGY] = "Kinetic Energy";
72 <    Stats::title_[TEMPERATURE] = "Temperature";
73 <    Stats::title_[PRESSURE] = "Pressure";
74 <    Stats::title_[VOLUME] = "Volume";
77 <    Stats::title_[HULLVOLUME] = "Hull Volume";
78 <    Stats::title_[GYRVOLUME] = "Gyrational Volume";
79 <    Stats::title_[CONSERVED_QUANTITY] = "Conserved Quantity";            
80 <    Stats::title_[TRANSLATIONAL_KINETIC] = "Translational Kinetic";
81 <    Stats::title_[ROTATIONAL_KINETIC] = "Rotational Kinetic";
82 <    Stats::title_[LONG_RANGE_POTENTIAL] = "Long Range Potential";
83 <    Stats::title_[SHORT_RANGE_POTENTIAL] = "Short Range Potential";
84 <    Stats::title_[VANDERWAALS_POTENTIAL] = "van der waals Potential";
85 <    Stats::title_[ELECTROSTATIC_POTENTIAL] = "Electrostatic Potential";    
86 <    Stats::title_[BOND_POTENTIAL] = "Bond Potential";
87 <    Stats::title_[BEND_POTENTIAL] = "Bend Potential";
88 <    Stats::title_[DIHEDRAL_POTENTIAL] = "Dihedral Potential";
89 <    Stats::title_[INVERSION_POTENTIAL] = "Inversion Potential";
90 <    Stats::title_[VRAW] = "Raw Potential";
91 <    Stats::title_[VHARM] = "Harmonic Potential";
92 <    Stats::title_[SHADOWH] = "Shadow Hamiltonian";
93 <    Stats::title_[PRESSURE_TENSOR_XX] = "P_xx";
94 <    Stats::title_[PRESSURE_TENSOR_XY] = "P_xy";
95 <    Stats::title_[PRESSURE_TENSOR_XZ] = "P_xz";
96 <    Stats::title_[PRESSURE_TENSOR_YX] = "P_yx";
97 <    Stats::title_[PRESSURE_TENSOR_YY] = "P_yy";
98 <    Stats::title_[PRESSURE_TENSOR_YZ] = "P_yz";
99 <    Stats::title_[PRESSURE_TENSOR_ZX] = "P_zx";
100 <    Stats::title_[PRESSURE_TENSOR_ZY] = "P_zy";
101 <    Stats::title_[PRESSURE_TENSOR_ZZ] = "P_zz";
102 <    Stats::title_[BOX_DIPOLE_X] = "box dipole x";
103 <    Stats::title_[BOX_DIPOLE_Y] = "box dipole y";
104 <    Stats::title_[BOX_DIPOLE_Z] = "box dipole z";
105 <    Stats::title_[TAGGED_PAIR_DISTANCE] = "Tagged_Pair_Distance";
106 <    Stats::title_[RNEMD_EXCHANGE_TOTAL] = "RNEMD_exchange_total";
107 <    Stats::title_[THERMAL_HELFANDMOMENT_X] = "Thermal Helfand Moment x";
108 <    Stats::title_[THERMAL_HELFANDMOMENT_Y] = "Thermal Helfand Moment y";
109 <    Stats::title_[THERMAL_HELFANDMOMENT_Z] = "Thermal Helfand Moment z";
110 <    Stats::title_[HEATFLUX_X]= "Heat Flux x component";  
111 <    Stats::title_[HEATFLUX_Y]= "Heat Flux y component";  
112 <    Stats::title_[HEATFLUX_Z]= "Heat Flux z component";  
68 >    StatsData time;
69 >    time.units =  "fs";
70 >    time.title =  "Time";
71 >    time.dataType = "RealType";
72 >    time.accumulator = new Accumulator();
73 >    data_[TIME] = time;
74 >    statsMap_["TIME"] = TIME;
75  
76 <    Stats::units_[TIME] = "fs";
77 <    Stats::units_[TOTAL_ENERGY] = "kcal/mol";
78 <    Stats::units_[POTENTIAL_ENERGY] = "kcal/mol";
79 <    Stats::units_[KINETIC_ENERGY] = "kcal/mol";
80 <    Stats::units_[TEMPERATURE] = "K";
81 <    Stats::units_[PRESSURE] = "atm";
82 <    Stats::units_[VOLUME] = "A^3";
83 <    Stats::units_[HULLVOLUME] = "A^3";
84 <    Stats::units_[GYRVOLUME] = "A^3";
85 <    Stats::units_[CONSERVED_QUANTITY] = "kcal/mol";            
86 <    Stats::units_[TRANSLATIONAL_KINETIC] = "kcal/mol";
87 <    Stats::units_[ROTATIONAL_KINETIC] = "kcal/mol";
88 <    Stats::units_[LONG_RANGE_POTENTIAL] = "kcal/mol";
89 <    Stats::units_[SHORT_RANGE_POTENTIAL] = "kcal/mol";
90 <    Stats::units_[VANDERWAALS_POTENTIAL] = "kcal/mol";
129 <    Stats::units_[ELECTROSTATIC_POTENTIAL] = "kcal/mol";
130 <    Stats::units_[BOND_POTENTIAL] = "kcal/mol";
131 <    Stats::units_[BEND_POTENTIAL] = "kcal/mol";
132 <    Stats::units_[DIHEDRAL_POTENTIAL] = "kcal/mol";
133 <    Stats::units_[INVERSION_POTENTIAL] = "kcal/mol";
134 <    Stats::units_[VRAW] = "kcal/mol";
135 <    Stats::units_[VHARM] = "kcal/mol";
136 <    Stats::units_[SHADOWH] = "kcal/mol";
137 <    Stats::units_[PRESSURE_TENSOR_XX] = "amu*fs^-2*Ang^-1";
138 <    Stats::units_[PRESSURE_TENSOR_XY] = "amu*fs^-2*Ang^-1";
139 <    Stats::units_[PRESSURE_TENSOR_XZ] = "amu*fs^-2*Ang^-1";
140 <    Stats::units_[PRESSURE_TENSOR_YX] = "amu*fs^-2*Ang^-1";
141 <    Stats::units_[PRESSURE_TENSOR_YY] = "amu*fs^-2*Ang^-1";
142 <    Stats::units_[PRESSURE_TENSOR_YZ] = "amu*fs^-2*Ang^-1";
143 <    Stats::units_[PRESSURE_TENSOR_ZX] = "amu*fs^-2*Ang^-1";
144 <    Stats::units_[PRESSURE_TENSOR_ZY] = "amu*fs^-2*Ang^-1";
145 <    Stats::units_[PRESSURE_TENSOR_ZZ] = "amu*fs^-2*Ang^-1";
146 <    Stats::units_[BOX_DIPOLE_X] = "C*m";
147 <    Stats::units_[BOX_DIPOLE_Y] = "C*m";
148 <    Stats::units_[BOX_DIPOLE_Z] = "C*m";
149 <    Stats::units_[TAGGED_PAIR_DISTANCE] = "Ang";
150 <    Stats::units_[RNEMD_EXCHANGE_TOTAL] = "Variable";
151 <    Stats::units_[THERMAL_HELFANDMOMENT_X] = "Ang*kcal/mol";
152 <    Stats::units_[THERMAL_HELFANDMOMENT_Y] = "Ang*kcal/mol";
153 <    Stats::units_[THERMAL_HELFANDMOMENT_Z] = "Ang*kcal/mol";
154 <    Stats::units_[HEATFLUX_X]="amu/fs^3";
155 <    Stats::units_[HEATFLUX_Y]="amu/fs^3";      
156 <    Stats::units_[HEATFLUX_Z]="amu/fs^3";      
76 >    StatsData total_energy;
77 >    total_energy.units =  "kcal/mol";
78 >    total_energy.title =  "Total Energy";
79 >    total_energy.dataType = "RealType";
80 >    total_energy.accumulator = new Accumulator();
81 >    data_[TOTAL_ENERGY] = total_energy;
82 >    statsMap_["TOTAL_ENERGY"] =  TOTAL_ENERGY;
83 >  
84 >    StatsData potential_energy;
85 >    potential_energy.units =  "kcal/mol";
86 >    potential_energy.title =  "Potential Energy";
87 >    potential_energy.dataType = "RealType";
88 >    potential_energy.accumulator = new Accumulator();
89 >    data_[POTENTIAL_ENERGY] = potential_energy;
90 >    statsMap_["POTENTIAL_ENERGY"] =  POTENTIAL_ENERGY;
91  
92 <    Stats::statsMap.insert(StatsMapType::value_type("TIME", TIME));
93 <    Stats::statsMap.insert(StatsMapType::value_type("TOTAL_ENERGY", TOTAL_ENERGY));
94 <    Stats::statsMap.insert(StatsMapType::value_type("POTENTIAL_ENERGY", POTENTIAL_ENERGY));
95 <    Stats::statsMap.insert(StatsMapType::value_type("KINETIC_ENERGY", KINETIC_ENERGY));
96 <    Stats::statsMap.insert(StatsMapType::value_type("TEMPERATURE", TEMPERATURE));
97 <    Stats::statsMap.insert(StatsMapType::value_type("PRESSURE", PRESSURE));
98 <    Stats::statsMap.insert(StatsMapType::value_type("VOLUME", VOLUME));
99 <    Stats::statsMap.insert(StatsMapType::value_type("HULLVOLUME", HULLVOLUME));
100 <    Stats::statsMap.insert(StatsMapType::value_type("GYRVOLUME", GYRVOLUME));
101 <    Stats::statsMap.insert(StatsMapType::value_type("CONSERVED_QUANTITY", CONSERVED_QUANTITY));
102 <    Stats::statsMap.insert(StatsMapType::value_type("TRANSLATIONAL_KINETIC", TRANSLATIONAL_KINETIC));
103 <    Stats::statsMap.insert(StatsMapType::value_type("ROTATIONAL_KINETIC", ROTATIONAL_KINETIC));
104 <    Stats::statsMap.insert(StatsMapType::value_type("LONG_RANGE_POTENTIAL", LONG_RANGE_POTENTIAL));
105 <    Stats::statsMap.insert(StatsMapType::value_type("SHORT_RANGE_POTENTIAL", SHORT_RANGE_POTENTIAL));
106 <    Stats::statsMap.insert(StatsMapType::value_type("VANDERWAALS_POTENTIAL", VANDERWAALS_POTENTIAL));
107 <    Stats::statsMap.insert(StatsMapType::value_type("ELECTROSTATIC_POTENTIAL", ELECTROSTATIC_POTENTIAL));
108 <    Stats::statsMap.insert(StatsMapType::value_type("BOND_POTENTIAL", BOND_POTENTIAL));
109 <    Stats::statsMap.insert(StatsMapType::value_type("BEND_POTENTIAL", BEND_POTENTIAL));
110 <    Stats::statsMap.insert(StatsMapType::value_type("DIHEDRAL_POTENTIAL", DIHEDRAL_POTENTIAL));
111 <    Stats::statsMap.insert(StatsMapType::value_type("INVERSION_POTENTIAL", INVERSION_POTENTIAL));
112 <    Stats::statsMap.insert(StatsMapType::value_type("VRAW", VRAW));    
113 <    Stats::statsMap.insert(StatsMapType::value_type("VHARM", VHARM));    
114 <    Stats::statsMap.insert(StatsMapType::value_type("PRESSURE_TENSOR_XX", PRESSURE_TENSOR_XX));    
115 <    Stats::statsMap.insert(StatsMapType::value_type("PRESSURE_TENSOR_XY", PRESSURE_TENSOR_XY));    
116 <    Stats::statsMap.insert(StatsMapType::value_type("PRESSURE_TENSOR_XZ", PRESSURE_TENSOR_XZ));    
117 <    Stats::statsMap.insert(StatsMapType::value_type("PRESSURE_TENSOR_YX", PRESSURE_TENSOR_YX));    
118 <    Stats::statsMap.insert(StatsMapType::value_type("PRESSURE_TENSOR_YY", PRESSURE_TENSOR_YY));    
119 <    Stats::statsMap.insert(StatsMapType::value_type("PRESSURE_TENSOR_YZ", PRESSURE_TENSOR_YZ));    
120 <    Stats::statsMap.insert(StatsMapType::value_type("PRESSURE_TENSOR_ZX", PRESSURE_TENSOR_ZX));    
121 <    Stats::statsMap.insert(StatsMapType::value_type("PRESSURE_TENSOR_ZY", PRESSURE_TENSOR_ZY));    
122 <    Stats::statsMap.insert(StatsMapType::value_type("PRESSURE_TENSOR_ZZ", PRESSURE_TENSOR_ZZ));    
123 <    Stats::statsMap.insert(StatsMapType::value_type("BOX_DIPOLE_X", BOX_DIPOLE_X));    
124 <    Stats::statsMap.insert(StatsMapType::value_type("BOX_DIPOLE_Y", BOX_DIPOLE_Y));    
125 <    Stats::statsMap.insert(StatsMapType::value_type("BOX_DIPOLE_Z", BOX_DIPOLE_Z));    
126 <    Stats::statsMap.insert(StatsMapType::value_type("TAGGED_PAIR_DISTANCE", TAGGED_PAIR_DISTANCE));    
127 <    Stats::statsMap.insert(StatsMapType::value_type("RNEMD_EXCHANGE_TOTAL", RNEMD_EXCHANGE_TOTAL));    
128 <    Stats::statsMap.insert(StatsMapType::value_type("SHADOWH", SHADOWH));
129 <    Stats::statsMap.insert(StatsMapType::value_type("THERMAL_HELFANDMOMENT_X",THERMAL_HELFANDMOMENT_X));
130 <    Stats::statsMap.insert(StatsMapType::value_type("THERMAL_HELFANDMOMENT_Y",THERMAL_HELFANDMOMENT_Y));
131 <    Stats::statsMap.insert(StatsMapType::value_type("THERMAL_HELFANDMOMENT_Z",THERMAL_HELFANDMOMENT_Z));
132 <    Stats::statsMap.insert(StatsMapType::value_type("HEATFLUX_X",HEATFLUX_X));
133 <    Stats::statsMap.insert(StatsMapType::value_type("HEATFLUX_Y",HEATFLUX_Y));
134 <    Stats::statsMap.insert(StatsMapType::value_type("HEATFLUX_Z",HEATFLUX_Z));
92 >    StatsData kinetic_energy;
93 >    kinetic_energy.units =  "kcal/mol";
94 >    kinetic_energy.title =  "Kinetic Energy";
95 >    kinetic_energy.dataType = "RealType";
96 >    kinetic_energy.accumulator = new Accumulator();
97 >    data_[KINETIC_ENERGY] = kinetic_energy;
98 >    statsMap_["KINETIC_ENERGY"] =  KINETIC_ENERGY;
99 >
100 >    StatsData temperature;
101 >    temperature.units =  "K";
102 >    temperature.title =  "Temperature";
103 >    temperature.dataType = "RealType";
104 >    temperature.accumulator = new Accumulator();
105 >    data_[TEMPERATURE] = temperature;
106 >    statsMap_["TEMPERATURE"] =  TEMPERATURE;
107 >
108 >    StatsData pressure;
109 >    pressure.units =  "atm";
110 >    pressure.title =  "Pressure";
111 >    pressure.dataType = "RealType";
112 >    pressure.accumulator = new Accumulator();
113 >    data_[PRESSURE] = pressure;
114 >    statsMap_["PRESSURE"] =  PRESSURE;
115 >
116 >    StatsData volume;
117 >    volume.units =  "A^3";
118 >    volume.title =  "Volume";
119 >    volume.dataType = "RealType";
120 >    volume.accumulator = new Accumulator();
121 >    data_[VOLUME] = volume;
122 >    statsMap_["VOLUME"] =  VOLUME;
123 >
124 >    StatsData hullvolume;
125 >    hullvolume.units =  "A^3";
126 >    hullvolume.title =  "Hull Volume";
127 >    hullvolume.dataType = "RealType";
128 >    hullvolume.accumulator = new Accumulator();
129 >    data_[HULLVOLUME] = hullvolume;
130 >    statsMap_["HULLVOLUME"] =  HULLVOLUME;
131 >
132 >    StatsData gyrvolume;
133 >    gyrvolume.units =  "A^3";
134 >    gyrvolume.title =  "Gyrational Volume";
135 >    gyrvolume.dataType = "RealType";
136 >    gyrvolume.accumulator = new Accumulator();
137 >    data_[GYRVOLUME] = gyrvolume;
138 >    statsMap_["GYRVOLUME"] =  GYRVOLUME;
139 >
140 >    StatsData conserved_quantity;
141 >    conserved_quantity.units =  "kcal/mol";            
142 >    conserved_quantity.title =  "Conserved Quantity";            
143 >    conserved_quantity.dataType = "RealType";
144 >    conserved_quantity.accumulator = new Accumulator();
145 >    data_[CONSERVED_QUANTITY] = conserved_quantity;
146 >    statsMap_["CONSERVED_QUANTITY"] =  CONSERVED_QUANTITY;
147 >
148 >    StatsData translational_kinetic;
149 >    translational_kinetic.units =  "kcal/mol";
150 >    translational_kinetic.title =  "Translational Kinetic";
151 >    translational_kinetic.dataType = "RealType";
152 >    translational_kinetic.accumulator = new Accumulator();
153 >    data_[TRANSLATIONAL_KINETIC] = translational_kinetic;
154 >    statsMap_["TRANSLATIONAL_KINETIC"] =  TRANSLATIONAL_KINETIC;
155 >
156 >    StatsData rotational_kinetic;
157 >    rotational_kinetic.units =  "kcal/mol";
158 >    rotational_kinetic.title =  "Rotational Kinetic";
159 >    rotational_kinetic.dataType = "RealType";
160 >    rotational_kinetic.accumulator = new Accumulator();
161 >    data_[ROTATIONAL_KINETIC] = rotational_kinetic;
162 >    statsMap_["ROTATIONAL_KINETIC"] =  ROTATIONAL_KINETIC;
163 >
164 >    StatsData long_range_potential;
165 >    long_range_potential.units =  "kcal/mol";
166 >    long_range_potential.title =  "Long Range Potential";
167 >    long_range_potential.dataType = "RealType";
168 >    long_range_potential.accumulator = new Accumulator();
169 >    data_[LONG_RANGE_POTENTIAL] = long_range_potential;
170 >    statsMap_["LONG_RANGE_POTENTIAL"] =  LONG_RANGE_POTENTIAL;
171 >
172 >    StatsData vanderwaals_potential;
173 >    vanderwaals_potential.units =  "kcal/mol";
174 >    vanderwaals_potential.title =  "van der waals Potential";
175 >    vanderwaals_potential.dataType = "RealType";
176 >    vanderwaals_potential.accumulator = new Accumulator();
177 >    data_[VANDERWAALS_POTENTIAL] = vanderwaals_potential;
178 >    statsMap_["VANDERWAALS_POTENTIAL"] =  VANDERWAALS_POTENTIAL;
179 >
180 >    StatsData electrostatic_potential;
181 >    electrostatic_potential.units =  "kcal/mol";
182 >    electrostatic_potential.title =  "Electrostatic Potential";    
183 >    electrostatic_potential.dataType = "RealType";
184 >    electrostatic_potential.accumulator = new Accumulator();
185 >    data_[ELECTROSTATIC_POTENTIAL] = electrostatic_potential;
186 >    statsMap_["ELECTROSTATIC_POTENTIAL"] =  ELECTROSTATIC_POTENTIAL;
187 >
188 >    StatsData metallic_potential;
189 >    metallic_potential.units =  "kcal/mol";
190 >    metallic_potential.title =  "Metallic Potential";    
191 >    metallic_potential.dataType = "RealType";
192 >    metallic_potential.accumulator = new Accumulator();
193 >    data_[METALLIC_POTENTIAL] = metallic_potential;
194 >    statsMap_["METALLIC_POTENTIAL"] =  METALLIC_POTENTIAL;
195 >
196 >    StatsData hydrogenbonding_potential;
197 >    hydrogenbonding_potential.units =  "kcal/mol";
198 >    hydrogenbonding_potential.title =  "Hydrogen Bonding Potential";    
199 >    hydrogenbonding_potential.dataType = "RealType";
200 >    hydrogenbonding_potential.accumulator = new Accumulator();
201 >    data_[HYDROGENBONDING_POTENTIAL] = hydrogenbonding_potential;
202 >    statsMap_["HYDROGENBONDING_POTENTIAL"] =  HYDROGENBONDING_POTENTIAL;
203 >
204 >    StatsData short_range_potential;
205 >    short_range_potential.units =  "kcal/mol";
206 >    short_range_potential.title =  "Short Range Potential";
207 >    short_range_potential.dataType = "RealType";
208 >    short_range_potential.accumulator = new Accumulator();
209 >    data_[SHORT_RANGE_POTENTIAL] = short_range_potential;
210 >    statsMap_["SHORT_RANGE_POTENTIAL"] =  SHORT_RANGE_POTENTIAL;
211 >
212 >    StatsData bond_potential;
213 >    bond_potential.units =  "kcal/mol";
214 >    bond_potential.title =  "Bond Potential";
215 >    bond_potential.dataType = "RealType";
216 >    bond_potential.accumulator = new Accumulator();
217 >    data_[BOND_POTENTIAL] = bond_potential;
218 >    statsMap_["BOND_POTENTIAL"] =  BOND_POTENTIAL;
219 >
220 >    StatsData bend_potential;
221 >    bend_potential.units =  "kcal/mol";
222 >    bend_potential.title =  "Bend Potential";
223 >    bend_potential.dataType = "RealType";
224 >    bend_potential.accumulator = new Accumulator();
225 >    data_[BEND_POTENTIAL] = bend_potential;
226 >    statsMap_["BEND_POTENTIAL"] =  BEND_POTENTIAL;
227 >    
228 >    StatsData dihedral_potential;
229 >    dihedral_potential.units =  "kcal/mol";
230 >    dihedral_potential.title =  "Dihedral Potential";
231 >    dihedral_potential.dataType = "RealType";
232 >    dihedral_potential.accumulator = new Accumulator();
233 >    data_[DIHEDRAL_POTENTIAL] = dihedral_potential;
234 >    statsMap_["DIHEDRAL_POTENTIAL"] =  DIHEDRAL_POTENTIAL;
235 >
236 >    StatsData inversion_potential;
237 >    inversion_potential.units =  "kcal/mol";
238 >    inversion_potential.title =  "Inversion Potential";
239 >    inversion_potential.dataType = "RealType";
240 >    inversion_potential.accumulator = new Accumulator();
241 >    data_[INVERSION_POTENTIAL] = inversion_potential;
242 >    statsMap_["INVERSION_POTENTIAL"] =  INVERSION_POTENTIAL;
243 >
244 >    StatsData vraw;
245 >    vraw.units =  "kcal/mol";
246 >    vraw.title =  "Raw Potential";
247 >    vraw.dataType = "RealType";
248 >    vraw.accumulator = new Accumulator();
249 >    data_[RAW_POTENTIAL] = vraw;
250 >    statsMap_["RAW_POTENTIAL"] =  RAW_POTENTIAL;
251 >
252 >    StatsData vrestraint;
253 >    vrestraint.units =  "kcal/mol";
254 >    vrestraint.title =  "Restraint Potential";
255 >    vrestraint.dataType = "RealType";
256 >    vrestraint.accumulator = new Accumulator();
257 >    data_[RESTRAINT_POTENTIAL] = vrestraint;
258 >    statsMap_["RESTRAINT_POTENTIAL"] =  RESTRAINT_POTENTIAL;
259 >
260 >    StatsData pressure_tensor;
261 >    pressure_tensor.units =  "amu*fs^-2*Ang^-1";
262 >    pressure_tensor.title =  "Ptensor";
263 >    pressure_tensor.dataType = "Mat3x3d";
264 >    pressure_tensor.accumulator = new MatrixAccumulator();
265 >    data_[PRESSURE_TENSOR] = pressure_tensor;
266 >    statsMap_["PRESSURE_TENSOR"] =  PRESSURE_TENSOR;
267 >
268 >    StatsData system_dipole;
269 >    system_dipole.units =  "C*m";
270 >    system_dipole.title =  "System Dipole";
271 >    system_dipole.dataType = "Vector3d";
272 >    system_dipole.accumulator = new VectorAccumulator();
273 >    data_[SYSTEM_DIPOLE] = system_dipole;
274 >    statsMap_["SYSTEM_DIPOLE"] =  SYSTEM_DIPOLE;
275 >
276 >    StatsData tagged_pair_distance;
277 >    tagged_pair_distance.units =  "Ang";
278 >    tagged_pair_distance.title =  "Tagged_Pair_Distance";
279 >    tagged_pair_distance.dataType = "RealType";
280 >    tagged_pair_distance.accumulator = new Accumulator();
281 >    data_[TAGGED_PAIR_DISTANCE] = tagged_pair_distance;
282 >    statsMap_["TAGGED_PAIR_DISTANCE"] =  TAGGED_PAIR_DISTANCE;
283 >
284 >    StatsData shadowh;
285 >    shadowh.units =  "kcal/mol";
286 >    shadowh.title =  "Shadow Hamiltonian";
287 >    shadowh.dataType = "RealType";
288 >    shadowh.accumulator = new Accumulator();
289 >    data_[SHADOWH] = shadowh;
290 >    statsMap_["SHADOWH"] =  SHADOWH;
291 >
292 >    StatsData helfandmoment;
293 >    helfandmoment.units =  "Ang*kcal/mol";
294 >    helfandmoment.title =  "Thermal Helfand Moment";
295 >    helfandmoment.dataType = "Vector3d";
296 >    helfandmoment.accumulator = new VectorAccumulator();
297 >    data_[HELFANDMOMENT] = helfandmoment;
298 >    statsMap_["HELFANDMOMENT"] = HELFANDMOMENT;
299 >
300 >    StatsData heatflux;
301 >    heatflux.units = "amu/fs^3";
302 >    heatflux.title =  "Heat Flux";  
303 >    heatflux.dataType = "Vector3d";
304 >    heatflux.accumulator = new VectorAccumulator();
305 >    data_[HEATFLUX] = heatflux;
306 >    statsMap_["HEATFLUX"] = HEATFLUX;
307 >
308 >    StatsData electronic_temperature;
309 >    electronic_temperature.units = "K";
310 >    electronic_temperature.title =  "Electronic Temperature";  
311 >    electronic_temperature.dataType = "RealType";
312 >    electronic_temperature.accumulator = new Accumulator();
313 >    data_[ELECTRONIC_TEMPERATURE] = electronic_temperature;
314 >    statsMap_["ELECTRONIC_TEMPERATURE"] = ELECTRONIC_TEMPERATURE;
315 >
316 >    StatsData com;
317 >    com.units =  "A";
318 >    com.title =  "Center of Mass";
319 >    com.dataType = "Vector3d";
320 >    com.accumulator = new VectorAccumulator();
321 >    data_[COM] = com;
322 >    statsMap_["COM"] =  COM;
323 >
324 >    StatsData comVel;
325 >    comVel.units =  "A/fs";
326 >    comVel.title =  "Center of Mass Velocity";
327 >    comVel.dataType = "Vector3d";
328 >    comVel.accumulator = new VectorAccumulator();
329 >    data_[COM_VELOCITY] = comVel;
330 >    statsMap_["COM_VELOCITY"] =  COM_VELOCITY;
331 >
332 >    StatsData angMom;
333 >    angMom.units =  "amu A^2/fs";
334 >    angMom.title =  "Angular Momentum";
335 >    angMom.dataType = "Vector3d";
336 >    angMom.accumulator = new VectorAccumulator();
337 >    data_[ANGULAR_MOMENTUM] = angMom;
338 >    statsMap_["ANGULAR_MOMENTUM"] =  ANGULAR_MOMENTUM;
339 >
340 >    // Now, set some defaults in the mask:
341 >
342 >    Globals* simParams = info_->getSimParams();
343 >    std::string statFileFormatString = simParams->getStatFileFormat();
344 >    parseStatFileFormat(statFileFormatString);
345 >
346 >    // if we're doing a thermodynamic integration, we'll want the raw
347 >    // potential as well as the full potential:
348 >    
349 >    if (simParams->getUseThermodynamicIntegration())
350 >      statsMask_.set(RAW_POTENTIAL);
351 >    
352 >    // if we've got restraints turned on, we'll also want a report of the
353 >    // total harmonic restraints
354 >    if (simParams->getUseRestraints()){
355 >      statsMask_.set(RESTRAINT_POTENTIAL);
356 >    }
357 >    
358 >    if (simParams->havePrintPressureTensor() &&
359 >        simParams->getPrintPressureTensor()){
360 >      statsMask_.set(PRESSURE_TENSOR);
361 >    }
362 >
363 >    // Why do we have both of these?
364 >    if (simParams->getAccumulateBoxDipole()) {
365 >      statsMask_.set(SYSTEM_DIPOLE);
366 >    }
367 >    if (info_->getCalcBoxDipole()){
368 >      statsMask_.set(SYSTEM_DIPOLE);
369 >    }
370 >
371 >    if (simParams->havePrintHeatFlux()) {
372 >      if (simParams->getPrintHeatFlux()){
373 >        statsMask_.set(HEATFLUX);
374 >      }
375 >    }    
376 >    
377 >    
378 >    if (simParams->haveTaggedAtomPair() && simParams->havePrintTaggedPairDistance()) {
379 >      if (simParams->getPrintTaggedPairDistance()) {
380 >        statsMask_.set(TAGGED_PAIR_DISTANCE);
381 >      }
382 >    }
383 >    
384    }
385  
386 +  void Stats::parseStatFileFormat(const std::string& format) {
387 +    StringTokenizer tokenizer(format, " ,;|\t\n\r");
388 +
389 +    while(tokenizer.hasMoreTokens()) {
390 +      std::string token(tokenizer.nextToken());
391 +      toUpper(token);
392 +      StatsMapType::iterator i = statsMap_.find(token);
393 +      if (i != statsMap_.end()) {
394 +        statsMask_.set(i->second);
395 +      } else {
396 +        sprintf( painCave.errMsg,
397 +                 "Stats::parseStatFileFormat: %s is not a recognized\n"
398 +                 "\tstatFileFormat keyword.\n", token.c_str() );
399 +        painCave.isFatal = 0;
400 +        painCave.severity = OPENMD_ERROR;
401 +        simError();            
402 +      }
403 +    }  
404 +  }
405 +
406 +
407 +  std::string Stats::getTitle(int index) {
408 +    assert(index >=0 && index < ENDINDEX);
409 +    return data_[index].title;
410 +  }
411 +
412 +  std::string Stats::getUnits(int index) {
413 +    assert(index >=0 && index < ENDINDEX);
414 +    return data_[index].units;
415 +  }
416 +
417 +  std::string Stats::getDataType(int index) {
418 +    assert(index >=0 && index < ENDINDEX);
419 +    return data_[index].dataType;
420 +  }
421 +
422 +  void Stats::collectStats(){
423 +    Globals* simParams = info_->getSimParams();
424 +    Snapshot* snap = info_->getSnapshotManager()->getCurrentSnapshot();
425 +    Thermo thermo(info_);
426 +  
427 +    for (unsigned int i = 0; i < statsMask_.size(); ++i) {
428 +      if (statsMask_[i]) {
429 +        switch (i) {
430 +        case TIME:
431 +          dynamic_cast<Accumulator *>(data_[i].accumulator)->add(snap->getTime());
432 +          break;
433 +        case KINETIC_ENERGY:
434 +          dynamic_cast<Accumulator *>(data_[i].accumulator)->add(thermo.getKinetic());
435 +          break;
436 +        case POTENTIAL_ENERGY:
437 +          dynamic_cast<Accumulator *>(data_[i].accumulator)->add(thermo.getPotential());
438 +          break;
439 +        case TOTAL_ENERGY:
440 +          dynamic_cast<Accumulator *>(data_[i].accumulator)->add(thermo.getTotalEnergy());
441 +          break;
442 +        case TEMPERATURE:
443 +          dynamic_cast<Accumulator *>(data_[i].accumulator)->add(thermo.getTemperature());
444 +          break;
445 +        case PRESSURE:
446 +          dynamic_cast<Accumulator *>(data_[i].accumulator)->add(thermo.getPressure());
447 +          break;
448 +        case VOLUME:
449 +          dynamic_cast<Accumulator *>(data_[i].accumulator)->add(thermo.getVolume());
450 +          break;
451 +        case CONSERVED_QUANTITY:
452 +          dynamic_cast<Accumulator *>(data_[i].accumulator)->add(snap->getConservedQuantity());
453 +          break;
454 +        case PRESSURE_TENSOR:
455 +          dynamic_cast<MatrixAccumulator *>(data_[i].accumulator)->add(thermo.getPressureTensor());
456 +          break;
457 +        case SYSTEM_DIPOLE:
458 +          dynamic_cast<VectorAccumulator *>(data_[i].accumulator)->add(thermo.getSystemDipole());
459 +          break;
460 +        case HEATFLUX:
461 +          dynamic_cast<VectorAccumulator *>(data_[i].accumulator)->add(thermo.getHeatFlux());
462 +          break;
463 +        case HULLVOLUME:
464 +          dynamic_cast<Accumulator *>(data_[i].accumulator)->add(thermo.getHullVolume());
465 +          break;
466 +        case GYRVOLUME:
467 +          dynamic_cast<Accumulator *>(data_[i].accumulator)->add(thermo.getGyrationalVolume());
468 +          break;
469 +        case TRANSLATIONAL_KINETIC:
470 +          dynamic_cast<Accumulator *>(data_[i].accumulator)->add(thermo.getTranslationalKinetic());
471 +          break;
472 +        case ROTATIONAL_KINETIC:
473 +          dynamic_cast<Accumulator *>(data_[i].accumulator)->add(thermo.getRotationalKinetic());
474 +          break;
475 +        case LONG_RANGE_POTENTIAL:
476 +          dynamic_cast<Accumulator *>(data_[i].accumulator)->add(snap->getLongRangePotential());
477 +          break;
478 +        case VANDERWAALS_POTENTIAL:
479 +          dynamic_cast<Accumulator *>(data_[i].accumulator)->add(snap->getLongRangePotentials()[VANDERWAALS_FAMILY]);
480 +          break;
481 +        case ELECTROSTATIC_POTENTIAL:
482 +          dynamic_cast<Accumulator *>(data_[i].accumulator)->add(snap->getLongRangePotentials()[ELECTROSTATIC_FAMILY]);
483 +          break;
484 +        case METALLIC_POTENTIAL:
485 +          dynamic_cast<Accumulator *>(data_[i].accumulator)->add(snap->getLongRangePotentials()[METALLIC_FAMILY]);
486 +          break;
487 +        case HYDROGENBONDING_POTENTIAL:
488 +          dynamic_cast<Accumulator *>(data_[i].accumulator)->add(snap->getLongRangePotentials()[HYDROGENBONDING_FAMILY]);
489 +          break;
490 +        case SHORT_RANGE_POTENTIAL:
491 +          dynamic_cast<Accumulator *>(data_[i].accumulator)->add(snap->getShortRangePotential());
492 +          break;
493 +        case BOND_POTENTIAL:
494 +          dynamic_cast<Accumulator *>(data_[i].accumulator)->add(snap->getBondPotential());
495 +          break;
496 +        case BEND_POTENTIAL:
497 +          dynamic_cast<Accumulator *>(data_[i].accumulator)->add(snap->getBendPotential());
498 +          break;
499 +        case DIHEDRAL_POTENTIAL:
500 +          dynamic_cast<Accumulator *>(data_[i].accumulator)->add(snap->getTorsionPotential());
501 +          break;
502 +        case INVERSION_POTENTIAL:
503 +          dynamic_cast<Accumulator *>(data_[i].accumulator)->add(snap->getInversionPotential());
504 +          break;
505 +        case RAW_POTENTIAL:
506 +          dynamic_cast<Accumulator *>(data_[i].accumulator)->add(snap->getRawPotential());
507 +          break;
508 +        case RESTRAINT_POTENTIAL:
509 +          dynamic_cast<Accumulator *>(data_[i].accumulator)->add(snap->getRestraintPotential());
510 +          break;
511 +        case TAGGED_PAIR_DISTANCE:
512 +          dynamic_cast<Accumulator *>(data_[i].accumulator)->add(thermo.getTaggedAtomPairDistance());
513 +          break;
514 +        case ELECTRONIC_TEMPERATURE:
515 +          dynamic_cast<Accumulator *>(data_[i].accumulator)->add(thermo.getElectronicTemperature());
516 +          break;
517 +        case COM:
518 +          dynamic_cast<VectorAccumulator *>(data_[i].accumulator)->add(thermo.getCom());
519 +          break;
520 +        case COM_VELOCITY:
521 +          dynamic_cast<VectorAccumulator *>(data_[i].accumulator)->add(thermo.getComVel());
522 +          break;
523 +        case ANGULAR_MOMENTUM:
524 +          dynamic_cast<VectorAccumulator *>(data_[i].accumulator)->add(thermo.getAngularMomentum());
525 +          break;
526 +          /*
527 +        case SHADOWH:
528 +          dynamic_cast<Accumulator *>(data_[i].accumulator)->add(thermo.getShadowHamiltionian());
529 +          break;
530 +        case HELFANDMOMENT:
531 +          dynamic_cast<Accumulator *>(data_[i].accumulator)->add(thermo.getHelfandMoment());
532 +          break;
533 +          */
534 +        }
535 +      }
536 +    }
537 +  }
538 +
539 +  int Stats::getIntData(int index) {
540 +    assert(index >=0 && index < ENDINDEX);
541 +    RealType value;
542 +    dynamic_cast<Accumulator *>(data_[index].accumulator)->getLastValue(value);
543 +    return (int) value;
544 +  }
545 +  RealType Stats::getRealData(int index) {
546 +    assert(index >=0 && index < ENDINDEX);
547 +    RealType value(0.0);
548 +    dynamic_cast<Accumulator *>(data_[index].accumulator)->getLastValue(value);
549 +    return value;
550 +  }
551 +  Vector3d Stats::getVectorData(int index) {
552 +    assert(index >=0 && index < ENDINDEX);
553 +    Vector3d value;
554 +    dynamic_cast<VectorAccumulator*>(data_[index].accumulator)->getLastValue(value);
555 +    return value;
556 +  }
557 +  Mat3x3d Stats::getMatrixData(int index) {
558 +    assert(index >=0 && index < ENDINDEX);
559 +    Mat3x3d value;
560 +    dynamic_cast<MatrixAccumulator*>(data_[index].accumulator)->getLastValue(value);
561 +    return value;
562 +  }
563 +
564 +  Stats::StatsBitSet Stats::getStatsMask() {
565 +    return statsMask_;
566 +  }
567 +  Stats::StatsMapType Stats::getStatsMap() {
568 +    return statsMap_;
569 +  }
570 +  void Stats::setStatsMask(Stats::StatsBitSet mask) {
571 +    statsMask_ = mask;
572 +  }
573 +
574   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines