Line data Source code
1 : /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2 : Copyright (c) 2016-2023 The plumed team
3 : (see the PEOPLE file at the root of the distribution for a list of names)
4 :
5 : See http://www.plumed.org for more information.
6 :
7 : This file is part of plumed, version 2.
8 :
9 : plumed is free software: you can redistribute it and/or modify
10 : it under the terms of the GNU Lesser General Public License as published by
11 : the Free Software Foundation, either version 3 of the License, or
12 : (at your option) any later version.
13 :
14 : plumed is distributed in the hope that it will be useful,
15 : but WITHOUT ANY WARRANTY; without even the implied warranty of
16 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 : GNU Lesser General Public License for more details.
18 :
19 : You should have received a copy of the GNU Lesser General Public License
20 : along with plumed. If not, see <http://www.gnu.org/licenses/>.
21 : +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
22 :
23 : /* This class was originally written by Thomas Loehr */
24 :
25 : #include "Colvar.h"
26 : #include "core/ActionRegister.h"
27 : #include "core/ActionSet.h"
28 : #include "core/PlumedMain.h"
29 : #include "core/GenericMolInfo.h"
30 : #include "tools/Communicator.h"
31 : #include "tools/OpenMP.h"
32 : #include <initializer_list>
33 :
34 : #define INV_PI_SQRT_PI 0.179587122
35 : #define KCAL_TO_KJ 4.184
36 : #define ANG_TO_NM 0.1
37 : #define ANG3_TO_NM3 0.001
38 :
39 : namespace PLMD {
40 : namespace colvar {
41 :
42 : //+PLUMEDOC COLVAR EEFSOLV
43 : /*
44 : Calculates EEF1 solvation free energy for a group of atoms.
45 :
46 : EEF1 is a solvent-accessible surface area based model, where the free energy of solvation is computed using a pairwise interaction term for non-hydrogen atoms:
47 : \f[
48 : \Delta G^\mathrm{solv}_i = \Delta G^\mathrm{ref}_i - \sum_{j \neq i} f_i(r_{ij}) V_j
49 : \f]
50 : where \f$\Delta G^\mathrm{solv}_i\f$ is the free energy of solvation, \f$\Delta G^\mathrm{ref}_i\f$ is the reference solvation free energy, \f$V_j\f$ is the volume of atom \f$j\f$ and
51 : \f[
52 : f_i(r) 4\pi r^2 = \frac{2}{\sqrt{\pi}} \frac{\Delta G^\mathrm{free}_i}{\lambda_i} \exp\left\{ - \frac{(r-R_i)^2}{\lambda^2_i}\right\}
53 : \f]
54 : where \f$\Delta G^\mathrm{free}_i\f$ is the solvation free energy of the isolated group, \f$\lambda_i\f$ is the correlation length equal to the width of the first solvation shell and \f$R_i\f$ is the van der Waals radius of atom \f$i\f$.
55 :
56 : The output from this collective variable, the free energy of solvation, can be used with the \ref BIASVALUE keyword to provide implicit solvation to a system. All parameters are designed to be used with a modified CHARMM36 force field. It takes only non-hydrogen atoms as input, these can be conveniently specified using the \ref GROUP action with the NDX_GROUP parameter. To speed up the calculation, EEFSOLV internally uses a neighbor list with a cutoff dependent on the type of atom (maximum of 1.95 nm). This cutoff can be extended further by using the NL_BUFFER keyword.
57 :
58 : \par Examples
59 :
60 : \plumedfile
61 : #SETTINGS MOLFILE=regtest/basic/rt77/peptide.pdb
62 : MOLINFO MOLTYPE=protein STRUCTURE=peptide.pdb
63 : WHOLEMOLECULES ENTITY0=1-111
64 :
65 : # This allows us to select only non-hydrogen atoms
66 : #SETTINGS AUXFILE=regtest/basic/rt77/index.ndx
67 : protein-h: GROUP NDX_FILE=index.ndx NDX_GROUP=Protein-H
68 :
69 : # We extend the cutoff by 0.1 nm and update the neighbor list every 40 steps
70 : solv: EEFSOLV ATOMS=protein-h
71 :
72 : # Here we actually add our calculated energy back to the potential
73 : bias: BIASVALUE ARG=solv
74 :
75 : PRINT ARG=solv FILE=SOLV
76 : \endplumedfile
77 :
78 : */
79 : //+ENDPLUMEDOC
80 :
81 : class EEFSolv : public Colvar {
82 : private:
83 : bool pbc;
84 : bool serial;
85 : double delta_g_ref;
86 : double nl_buffer;
87 : unsigned nl_stride;
88 : unsigned nl_update;
89 : std::vector<std::vector<unsigned> > nl;
90 : std::vector<std::vector<bool> > nlexpo;
91 : std::vector<std::vector<double> > parameter;
92 : void setupConstants(const std::vector<AtomNumber> &atoms, std::vector<std::vector<double> > ¶meter, bool tcorr);
93 : std::map<std::string, std::map<std::string, std::string> > setupTypeMap();
94 : std::map<std::string, std::vector<double> > setupValueMap();
95 : void update_neighb();
96 :
97 : public:
98 : static void registerKeywords(Keywords& keys);
99 : explicit EEFSolv(const ActionOptions&);
100 : void calculate() override;
101 : };
102 :
103 : PLUMED_REGISTER_ACTION(EEFSolv,"EEFSOLV")
104 :
105 7 : void EEFSolv::registerKeywords(Keywords& keys) {
106 7 : Colvar::registerKeywords(keys);
107 14 : keys.add("atoms", "ATOMS", "The atoms to be included in the calculation, e.g. the whole protein.");
108 14 : keys.add("compulsory", "NL_BUFFER", "0.1", "The buffer to the intrinsic cutoff used when calculating pairwise interactions.");
109 14 : keys.add("compulsory", "NL_STRIDE", "40", "The frequency with which the neighbor list is updated.");
110 14 : keys.addFlag("SERIAL",false,"Perform the calculation in serial - for debug purpose");
111 14 : keys.addFlag("TEMP_CORRECTION", false, "Correct free energy of solvation constants for temperatures different from 298.15 K");
112 7 : keys.setValueDescription("the EEF1 solvation free energy for the input atoms");
113 7 : }
114 :
115 5 : EEFSolv::EEFSolv(const ActionOptions&ao):
116 : PLUMED_COLVAR_INIT(ao),
117 5 : pbc(true),
118 5 : serial(false),
119 5 : delta_g_ref(0.),
120 5 : nl_buffer(0.1),
121 5 : nl_stride(40),
122 5 : nl_update(0) {
123 : std::vector<AtomNumber> atoms;
124 10 : parseAtomList("ATOMS", atoms);
125 : const unsigned size = atoms.size();
126 5 : bool tcorr = false;
127 5 : parseFlag("TEMP_CORRECTION", tcorr);
128 5 : parse("NL_BUFFER", nl_buffer);
129 5 : parse("NL_STRIDE", nl_stride);
130 :
131 5 : bool nopbc = !pbc;
132 5 : parseFlag("NOPBC", nopbc);
133 5 : pbc = !nopbc;
134 :
135 5 : parseFlag("SERIAL",serial);
136 :
137 5 : checkRead();
138 :
139 10 : log << " Bibliography " << plumed.cite("Lazaridis T, Karplus M, Proteins Struct. Funct. Genet. 35, 133 (1999)");
140 5 : log << "\n";
141 :
142 5 : nl.resize(size);
143 5 : nlexpo.resize(size);
144 5 : parameter.resize(size, std::vector<double>(4, 0));
145 5 : setupConstants(atoms, parameter, tcorr);
146 :
147 5 : addValueWithDerivatives();
148 5 : setNotPeriodic();
149 5 : requestAtoms(atoms);
150 5 : }
151 :
152 30 : void EEFSolv::update_neighb() {
153 : const double lower_c2 = 0.24 * 0.24; // this is the cut-off for bonded atoms
154 : const unsigned size = getNumberOfAtoms();
155 :
156 1830 : for (unsigned i=0; i<size; i++) {
157 1800 : nl[i].clear();
158 : nlexpo[i].clear();
159 1800 : const Vector posi = getPosition(i);
160 : // Loop through neighboring atoms, add the ones below cutoff
161 54900 : for (unsigned j=i+1; j<size; j++) {
162 53100 : if(parameter[i][1]==0&¶meter[j][1]==0) {
163 1350 : continue;
164 : }
165 51750 : const double d2 = delta(posi, getPosition(j)).modulo2();
166 51750 : if (d2 < lower_c2 && j < i+14) {
167 : // crude approximation for i-i+1/2 interactions,
168 : // we want to exclude atoms separated by less than three bonds
169 2695 : continue;
170 : }
171 : // We choose the maximum lambda value and use a more conservative cutoff
172 49055 : double mlambda = 1./parameter[i][2];
173 49055 : if (1./parameter[j][2] > mlambda) {
174 : mlambda = 1./parameter[j][2];
175 : }
176 49055 : const double c2 = (2. * mlambda + nl_buffer) * (2. * mlambda + nl_buffer);
177 49055 : if (d2 < c2 ) {
178 26069 : nl[i].push_back(j);
179 26069 : if(parameter[i][2] == parameter[j][2] && parameter[i][3] == parameter[j][3]) {
180 5175 : nlexpo[i].push_back(true);
181 : } else {
182 20894 : nlexpo[i].push_back(false);
183 : }
184 : }
185 : }
186 : }
187 30 : }
188 :
189 30 : void EEFSolv::calculate() {
190 30 : if(pbc) {
191 30 : makeWhole();
192 : }
193 30 : if(getExchangeStep()) {
194 0 : nl_update = 0;
195 : }
196 30 : if(nl_update==0) {
197 30 : update_neighb();
198 : }
199 :
200 : const unsigned size=getNumberOfAtoms();
201 30 : double bias = 0.0;
202 30 : std::vector<Vector> deriv(size, Vector(0,0,0));
203 :
204 : unsigned stride;
205 : unsigned rank;
206 30 : if(serial) {
207 : stride=1;
208 : rank=0;
209 : } else {
210 30 : stride=comm.Get_size();
211 30 : rank=comm.Get_rank();
212 : }
213 :
214 30 : unsigned nt=OpenMP::getNumThreads();
215 30 : if(nt*stride*10>size) {
216 : nt=1;
217 : }
218 :
219 30 : #pragma omp parallel num_threads(nt)
220 : {
221 : std::vector<Vector> deriv_omp(size, Vector(0,0,0));
222 : #pragma omp for reduction(+:bias) nowait
223 : for (unsigned i=rank; i<size; i+=stride) {
224 : const Vector posi = getPosition(i);
225 : double fedensity = 0.0;
226 : Vector deriv_i;
227 : const double vdw_volume_i = parameter[i][0];
228 : const double delta_g_free_i = parameter[i][1];
229 : const double inv_lambda_i = parameter[i][2];
230 : const double vdw_radius_i = parameter[i][3];
231 :
232 : // The pairwise interactions are unsymmetric, but we can get away with calculating the distance only once
233 : for (unsigned i_nl=0; i_nl<nl[i].size(); i_nl++) {
234 : const unsigned j = nl[i][i_nl];
235 : const double vdw_volume_j = parameter[j][0];
236 : const double delta_g_free_j = parameter[j][1];
237 : const double inv_lambda_j = parameter[j][2];
238 : const double vdw_radius_j = parameter[j][3];
239 :
240 : const Vector dist = delta(posi, getPosition(j));
241 : const double rij = dist.modulo();
242 : const double inv_rij = 1.0 / rij;
243 : const double inv_rij2 = inv_rij * inv_rij;
244 : const double fact_ij = inv_rij2 * delta_g_free_i * vdw_volume_j * INV_PI_SQRT_PI * inv_lambda_i;
245 : const double fact_ji = inv_rij2 * delta_g_free_j * vdw_volume_i * INV_PI_SQRT_PI * inv_lambda_j;
246 :
247 : // in this case we can calculate a single exponential
248 : if(!nlexpo[i][i_nl]) {
249 : // i-j interaction
250 : if(inv_rij > 0.5*inv_lambda_i && delta_g_free_i!=0.) {
251 : const double e_arg = (rij - vdw_radius_i)*inv_lambda_i;
252 : const double expo = std::exp(-e_arg*e_arg);
253 : const double fact = expo*fact_ij;
254 : const double e_deriv = inv_rij*fact*(inv_rij + e_arg*inv_lambda_i);
255 : const Vector dd = e_deriv*dist;
256 : fedensity += fact;
257 : deriv_i += dd;
258 : if(nt>1) {
259 : deriv_omp[j] -= dd;
260 : } else {
261 : deriv[j] -= dd;
262 : }
263 : }
264 :
265 : // j-i interaction
266 : if(inv_rij > 0.5*inv_lambda_j && delta_g_free_j!=0.) {
267 : const double e_arg = (rij - vdw_radius_j)*inv_lambda_j;
268 : const double expo = std::exp(-e_arg*e_arg);
269 : const double fact = expo*fact_ji;
270 : const double e_deriv = inv_rij*fact*(inv_rij + e_arg*inv_lambda_j);
271 : const Vector dd = e_deriv*dist;
272 : fedensity += fact;
273 : deriv_i += dd;
274 : if(nt>1) {
275 : deriv_omp[j] -= dd;
276 : } else {
277 : deriv[j] -= dd;
278 : }
279 : }
280 : } else {
281 : // i-j interaction
282 : if(inv_rij > 0.5*inv_lambda_i) {
283 : const double e_arg = (rij - vdw_radius_i)*inv_lambda_i;
284 : const double expo = std::exp(-e_arg*e_arg);
285 : const double fact = expo*(fact_ij + fact_ji);
286 : const double e_deriv = inv_rij*fact*(inv_rij + e_arg*inv_lambda_i);
287 : const Vector dd = e_deriv*dist;
288 : fedensity += fact;
289 : deriv_i += dd;
290 : if(nt>1) {
291 : deriv_omp[j] -= dd;
292 : } else {
293 : deriv[j] -= dd;
294 : }
295 : }
296 : }
297 :
298 : }
299 : if(nt>1) {
300 : deriv_omp[i] += deriv_i;
301 : } else {
302 : deriv[i] += deriv_i;
303 : }
304 : bias += 0.5*fedensity;
305 : }
306 : #pragma omp critical
307 : if(nt>1)
308 : for(unsigned i=0; i<size; i++) {
309 : deriv[i]+=deriv_omp[i];
310 : }
311 : }
312 :
313 30 : if(!serial) {
314 30 : comm.Sum(bias);
315 30 : if(!deriv.empty()) {
316 30 : comm.Sum(&deriv[0][0],3*deriv.size());
317 : }
318 : }
319 :
320 30 : Tensor virial;
321 1830 : for(unsigned i=0; i<size; i++) {
322 1800 : setAtomsDerivatives(i, -deriv[i]);
323 1800 : virial += Tensor(getPosition(i), -deriv[i]);
324 : }
325 30 : setBoxDerivatives(-virial);
326 30 : setValue(delta_g_ref - bias);
327 :
328 : // Keep track of the neighbourlist updates
329 30 : nl_update++;
330 30 : if (nl_update == nl_stride) {
331 30 : nl_update = 0;
332 : }
333 30 : }
334 :
335 5 : void EEFSolv::setupConstants(const std::vector<AtomNumber> &atoms, std::vector<std::vector<double> > ¶meter, bool tcorr) {
336 : std::vector<std::vector<double> > parameter_temp;
337 10 : parameter_temp.resize(atoms.size(), std::vector<double>(7,0));
338 : std::map<std::string, std::vector<double> > valuemap;
339 : std::map<std::string, std::map<std::string, std::string> > typemap;
340 5 : valuemap = setupValueMap();
341 5 : typemap = setupTypeMap();
342 5 : auto * moldat = plumed.getActionSet().selectLatest<GenericMolInfo*>(this);
343 : bool cter=false;
344 5 : if (moldat) {
345 5 : log<<" MOLINFO DATA found with label " <<moldat->getLabel()<<", using proper atom names\n";
346 305 : for(unsigned i=0; i<atoms.size(); ++i) {
347 :
348 : // Get atom and residue names
349 300 : std::string Aname = moldat->getAtomName(atoms[i]);
350 300 : std::string Rname = moldat->getResidueName(atoms[i]);
351 300 : std::string Atype = typemap[Rname][Aname];
352 :
353 : // Check for terminal COOH or COO- (different atomtypes & parameters!)
354 598 : if (Aname == "OT1" || Aname == "OXT") {
355 : // We create a temporary AtomNumber object to access future atoms
356 : unsigned ai = atoms[i].index();
357 : AtomNumber tmp_an;
358 2 : tmp_an.setIndex(ai + 2);
359 2 : if (moldat->checkForAtom(tmp_an) && moldat->getAtomName(tmp_an) == "HT2") {
360 : // COOH
361 : Atype = "OB";
362 : } else {
363 : // COO-
364 : Atype = "OC";
365 : }
366 : cter = true;
367 : }
368 302 : if (Aname == "OT2" || (cter == true && Aname == "O")) {
369 : unsigned ai = atoms[i].index();
370 : AtomNumber tmp_an;
371 2 : tmp_an.setIndex(ai + 1);
372 2 : if (moldat->checkForAtom(tmp_an) && moldat->getAtomName(tmp_an) == "HT2") {
373 : // COOH
374 : Atype = "OH1";
375 : } else {
376 : // COO-
377 : Atype = "OC";
378 : }
379 : }
380 :
381 : // Check for H-atoms
382 : char type;
383 300 : char first = Aname.at(0);
384 :
385 : // GOLDEN RULE: type is first letter, if not a number
386 300 : if (!isdigit(first)) {
387 : type = first;
388 : // otherwise is the second
389 : } else {
390 0 : type = Aname.at(1);
391 : }
392 :
393 300 : if (type == 'H') {
394 0 : error("EEF1-SB does not allow the use of hydrogen atoms!\n");
395 : }
396 :
397 : // Lookup atomtype in table or throw exception if its not there
398 : try {
399 300 : parameter_temp[i] = valuemap.at(Atype);
400 0 : } catch (const std::exception &e) {
401 0 : log << "Type: " << Atype << " Name: " << Aname << " Residue: " << Rname << "\n";
402 0 : error("Invalid atom type!\n");
403 0 : }
404 :
405 : // Temperature correction
406 300 : if (tcorr && parameter[i][1] > 0.0) {
407 : const double t0 = 298.15;
408 0 : const double delta_g_ref_t0 = parameter_temp[i][1];
409 0 : const double delta_h_ref_t0 = parameter_temp[i][3];
410 0 : const double delta_cp = parameter_temp[i][4];
411 0 : const double delta_s_ref_t0 = (delta_h_ref_t0 - delta_g_ref_t0) / t0;
412 0 : const double t = getkBT() / getKBoltzmann();
413 0 : parameter_temp[i][1] -= delta_s_ref_t0 * (t - t0) - delta_cp * t * std::log(t / t0) + delta_cp * (t - t0);
414 0 : parameter_temp[i][2] *= parameter_temp[i][1] / delta_g_ref_t0;
415 : }
416 300 : parameter[i][0] = parameter_temp[i][0];
417 300 : parameter[i][1] = parameter_temp[i][2];
418 300 : parameter[i][2] = parameter_temp[i][5];
419 300 : parameter[i][3] = parameter_temp[i][6];
420 : }
421 : } else {
422 0 : error("MOLINFO DATA not found\n");
423 : }
424 305 : for(unsigned i=0; i<atoms.size(); ++i) {
425 300 : delta_g_ref += parameter_temp[i][1];
426 : }
427 5 : }
428 :
429 5 : std::map<std::string, std::map<std::string, std::string> > EEFSolv::setupTypeMap() {
430 : std::map<std::string, std::map<std::string, std::string> > typemap;
431 10 : typemap["ACE"] = {
432 : {"CH3", "CT3"},
433 : {"HH31","HA3"},
434 : {"HH32","HA3"},
435 : {"HH33","HA3"},
436 : {"C", "C" },
437 : {"O", "O" }
438 40 : };
439 10 : typemap["ALA"] = {
440 : {"N", "NH1"},
441 : {"HN", "H" },
442 : {"CA", "CT1"},
443 : {"HA", "HB1"},
444 : {"CB", "CT3"},
445 : {"HB1", "HA3"},
446 : {"HB2", "HA3"},
447 : {"HB3", "HA3"},
448 : {"C", "C" },
449 : {"O", "O" }
450 60 : };
451 10 : typemap["ARG"] = {
452 : {"N", "NH1"},
453 : {"HN", "H" },
454 : {"CA", "CT1"},
455 : {"HA", "HB1"},
456 : {"CB", "CT2"},
457 : {"HB1", "HA2"},
458 : {"HB2", "HA2"},
459 : {"CG", "CT2"},
460 : {"HG1", "HA2"},
461 : {"HG2", "HA2"},
462 : {"CD", "CT2"},
463 : {"HD1", "HA2"},
464 : {"HD2", "HA2"},
465 : {"NE", "NC2"},
466 : {"HE", "HC" },
467 : {"CZ", "C" },
468 : {"NH1", "NC2"},
469 : {"HH11", "HC" },
470 : {"HH12", "HC" },
471 : {"NH2", "NC2"},
472 : {"HH21", "HC" },
473 : {"HH22", "HC" },
474 : {"C", "C" },
475 : {"O", "O" }
476 130 : };
477 10 : typemap["ASN"] = {
478 : {"N", "NH1"},
479 : {"HN", "H" },
480 : {"CA", "CT1"},
481 : {"HA", "HB1"},
482 : {"CB", "CT2"},
483 : {"HB1", "HA2"},
484 : {"HB2", "HA2"},
485 : {"CG", "CC" },
486 : {"OD1", "O" },
487 : {"ND2", "NH2"},
488 : {"HD21", "H" },
489 : {"HD22", "H" },
490 : {"C", "C" },
491 : {"O", "O" }
492 80 : };
493 10 : typemap["ASPP"] = {
494 : {"N", "NH1"},
495 : {"HN", "H" },
496 : {"CA", "CT1"},
497 : {"HA", "HB1"},
498 : {"CB", "CT2"},
499 : {"HB1", "HA2"},
500 : {"HB2", "HA2"},
501 : {"CG", "CD" },
502 : {"OD1", "OB" },
503 : {"OD2", "OH1"},
504 : {"HD2", "H" },
505 : {"C", "C" },
506 : {"O", "O" }
507 75 : };
508 10 : typemap["ASP"] = {
509 : {"N", "NH1"},
510 : {"HN", "H" },
511 : {"CA", "CT1"},
512 : {"HA", "HB1"},
513 : {"CB", "CT2"},
514 : {"HB1", "HA2"},
515 : {"HB2", "HA2"},
516 : {"CG", "CC" },
517 : {"OD1", "OC" },
518 : {"OD2", "OC" },
519 : {"C", "C" },
520 : {"O", "O" }
521 70 : };
522 10 : typemap["CYS"] = {
523 : {"N", "NH1"},
524 : {"HN", "H" },
525 : {"CA", "CT1"},
526 : {"HA", "HB1"},
527 : {"CB", "CT2"},
528 : {"HB1", "HA2"},
529 : {"HB2", "HA2"},
530 : {"SG", "S" },
531 : {"HG1", "HS" },
532 : {"C", "C" },
533 : {"O", "O" }
534 65 : };
535 10 : typemap["GLN"] = {
536 : {"N", "NH1" },
537 : {"HN", "H" },
538 : {"CA", "CT1" },
539 : {"HA", "HB1" },
540 : {"CB", "CT2" },
541 : {"HB1", "HA2" },
542 : {"HB2", "HA2" },
543 : {"CG", "CT2" },
544 : {"HG1", "HA2" },
545 : {"HG2", "HA2" },
546 : {"CD", "CC" },
547 : {"OE1", "O" },
548 : {"NE2", "NH2" },
549 : {"HE21", "H" },
550 : {"HE22", "H" },
551 : {"C", "C" },
552 : {"O", "O" }
553 95 : };
554 10 : typemap["GLUP"] = {
555 : {"N", "NH1"},
556 : {"HN", "H" },
557 : {"CA", "CT1"},
558 : {"HA", "HB1"},
559 : {"CB", "CT2"},
560 : {"HB1", "HA2"},
561 : {"HB2", "HA2"},
562 : {"CG", "CT2"},
563 : {"HG1", "HA2"},
564 : {"HG2", "HA2"},
565 : {"CD", "CD" },
566 : {"OE1", "OB" },
567 : {"OE2", "OH1"},
568 : {"HE2", "H" },
569 : {"C", "C" },
570 : {"O", "O" }
571 90 : };
572 10 : typemap["GLU"] = {
573 : {"N", "NH1"},
574 : {"HN", "H" },
575 : {"CA", "CT1"},
576 : {"HA", "HB1"},
577 : {"CB", "CT2"},
578 : {"HB1", "HA2"},
579 : {"HB2", "HA2"},
580 : {"CG", "CT2"},
581 : {"HG1", "HA2"},
582 : {"HG2", "HA2"},
583 : {"CD", "CC" },
584 : {"OE1", "OC" },
585 : {"OE2", "OC" },
586 : {"C", "C" },
587 : {"O", "O" }
588 85 : };
589 10 : typemap["GLY"] = {
590 : {"N", "NH1"},
591 : {"HN", "H" },
592 : {"CA", "CT2"},
593 : {"HA1", "HB2"},
594 : {"HA2", "HB2"},
595 : {"C", "C" },
596 : {"O", "O" }
597 45 : };
598 10 : typemap["HSD"] = {
599 : {"N", "NH1"},
600 : {"HN", "H" },
601 : {"CA", "CT1"},
602 : {"HA", "HB1"},
603 : {"CB", "CT2"},
604 : {"HB1", "HA2"},
605 : {"HB2", "HA2"},
606 : {"ND1", "NR1"},
607 : {"HD1", "H" },
608 : {"CG", "CPH1"},
609 : {"CE1", "CPH2"},
610 : {"HE1", "HR1"},
611 : {"NE2", "NR2"},
612 : {"CD2", "CPH1"},
613 : {"HD2", "HR3"},
614 : {"C", "C" },
615 : {"O", "O" }
616 95 : };
617 10 : typemap["HIS"] = {
618 : {"N", "NH1"},
619 : {"HN", "H" },
620 : {"CA", "CT1"},
621 : {"HA", "HB1"},
622 : {"CB", "CT2"},
623 : {"HB1", "HA2"},
624 : {"HB2", "HA2"},
625 : {"ND1", "NR2"},
626 : {"CG", "CPH1"},
627 : {"CE1", "CPH2"},
628 : {"HE1", "HR1"},
629 : {"NE2", "NR1"},
630 : {"HE2", "H" },
631 : {"CD2", "CPH1"},
632 : {"HD2", "HR3"},
633 : {"C", "C" },
634 : {"O", "O" }
635 95 : };
636 10 : typemap["HSE"] = {
637 : {"N", "NH1"},
638 : {"HN", "H" },
639 : {"CA", "CT1"},
640 : {"HA", "HB1"},
641 : {"CB", "CT2"},
642 : {"HB1", "HA2"},
643 : {"HB2", "HA2"},
644 : {"ND1", "NR2"},
645 : {"CG", "CPH1"},
646 : {"CE1", "CPH2"},
647 : {"HE1", "HR1"},
648 : {"NE2", "NR1"},
649 : {"HE2", "H" },
650 : {"CD2", "CPH1"},
651 : {"HD2", "HR3"},
652 : {"C", "C" },
653 : {"O", "O" }
654 95 : };
655 10 : typemap["HSP"] = {
656 : {"N", "NH1"},
657 : {"HN", "H" },
658 : {"CA", "CT1"},
659 : {"HA", "HB1"},
660 : {"CB", "CT2"},
661 : {"HB1", "HA2"},
662 : {"HB2", "HA2"},
663 : {"CD2", "CPH1"},
664 : {"HD2", "HR1"},
665 : {"CG", "CPH1"},
666 : {"NE2", "NR3"},
667 : {"HE2", "H" },
668 : {"ND1", "NR3"},
669 : {"HD1", "H" },
670 : {"CE1", "CPH2"},
671 : {"HE1", "HR2"},
672 : {"C", "C" },
673 : {"O", "O" }
674 100 : };
675 10 : typemap["ILE"] = {
676 : {"N", "NH1"},
677 : {"HN", "H" },
678 : {"CA", "CT1"},
679 : {"HA", "HB1"},
680 : {"CB", "CT1"},
681 : {"HB", "HA1"},
682 : {"CG2", "CT3"},
683 : {"HG21", "HA3"},
684 : {"HG22", "HA3"},
685 : {"HG23", "HA3"},
686 : {"CG1", "CT2"},
687 : {"HG11", "HA2"},
688 : {"HG12", "HA2"},
689 : {"CD", "CT3"},
690 : {"HD1", "HA3"},
691 : {"HD2", "HA3"},
692 : {"HD3", "HA3"},
693 : {"C", "C" },
694 : {"O", "O" }
695 105 : };
696 10 : typemap["LEU"] = {
697 : {"N", "NH1"},
698 : {"HN", "H" },
699 : {"CA", "CT1"},
700 : {"HA", "HB1"},
701 : {"CB", "CT2"},
702 : {"HB1", "HA2"},
703 : {"HB2", "HA2"},
704 : {"CG", "CT1"},
705 : {"HG", "HA1"},
706 : {"CD1", "CT3"},
707 : {"HD11", "HA3"},
708 : {"HD12", "HA3"},
709 : {"HD13", "HA3"},
710 : {"CD2", "CT3"},
711 : {"HD21", "HA3"},
712 : {"HD22", "HA3"},
713 : {"HD23", "HA3"},
714 : {"C", "C" },
715 : {"O", "O" }
716 105 : };
717 10 : typemap["LYS"] = {
718 : {"N", "NH1"},
719 : {"HN", "H" },
720 : {"CA", "CT1"},
721 : {"HA", "HB1"},
722 : {"CB", "CT2"},
723 : {"HB1", "HA2"},
724 : {"HB2", "HA2"},
725 : {"CG", "CT2"},
726 : {"HG1", "HA2"},
727 : {"HG2", "HA2"},
728 : {"CD", "CT2"},
729 : {"HD1", "HA2"},
730 : {"HD2", "HA2"},
731 : {"CE", "CT2"},
732 : {"HE1", "HA2"},
733 : {"HE2", "HA2"},
734 : {"NZ", "NH3"},
735 : {"HZ1", "HC" },
736 : {"HZ2", "HC" },
737 : {"HZ3", "HC" },
738 : {"C", "C" },
739 : {"O", "O" }
740 120 : };
741 10 : typemap["MET"] = {
742 : {"N", "NH1"},
743 : {"HN", "H" },
744 : {"CA", "CT1"},
745 : {"HA", "HB1"},
746 : {"CB", "CT2"},
747 : {"HB1", "HA2"},
748 : {"HB2", "HA2"},
749 : {"CG", "CT2"},
750 : {"HG1", "HA2"},
751 : {"HG2", "HA2"},
752 : {"SD", "S" },
753 : {"CE", "CT3"},
754 : {"HE1", "HA3"},
755 : {"HE2", "HA3"},
756 : {"HE3", "HA3"},
757 : {"C", "C" },
758 : {"O", "O" }
759 95 : };
760 10 : typemap["NMA"] = {
761 : {"N", "NH1"},
762 : {"HN", "H" },
763 : {"CH3", "CT3"},
764 : {"HH31","HA3"},
765 : {"HH32","HA3"},
766 : {"HH33","HA3"},
767 40 : };
768 10 : typemap["PHE"] = {
769 : {"N", "NH1"},
770 : {"HN", "H" },
771 : {"CA", "CT1"},
772 : {"HA", "HB1"},
773 : {"CB", "CT2"},
774 : {"HB1", "HA2"},
775 : {"HB2", "HA2"},
776 : {"CG", "CA" },
777 : {"CD1", "CA" },
778 : {"HD1", "HP" },
779 : {"CE1", "CA" },
780 : {"HE1", "HP" },
781 : {"CZ", "CA" },
782 : {"HZ", "HP" },
783 : {"CD2", "CA" },
784 : {"HD2", "HP" },
785 : {"CE2", "CA" },
786 : {"HE2", "HP" },
787 : {"C", "C" },
788 : {"O", "O" }
789 110 : };
790 10 : typemap["PRO"] = {
791 : {"N", "N" },
792 : {"CD", "CP3"},
793 : {"HD1", "HA2"},
794 : {"HD2", "HA2"},
795 : {"CA", "CP1"},
796 : {"HA", "HB1"},
797 : {"CB", "CP2"},
798 : {"HB1", "HA2"},
799 : {"HB2", "HA2"},
800 : {"CG", "CP2"},
801 : {"HG1", "HA2"},
802 : {"HG2", "HA2"},
803 : {"C", "C" },
804 : {"O", "O" }
805 80 : };
806 10 : typemap["SER"] = {
807 : {"N", "NH1"},
808 : {"HN", "H" },
809 : {"CA", "CT1"},
810 : {"HA", "HB1"},
811 : {"CB", "CT2"},
812 : {"HB1", "HA2"},
813 : {"HB2", "HA2"},
814 : {"OG", "OH1"},
815 : {"HG1", "H" },
816 : {"C", "C" },
817 : {"O", "O" }
818 65 : };
819 10 : typemap["THR"] = {
820 : {"N", "NH1"},
821 : {"HN", "H" },
822 : {"CA", "CT1"},
823 : {"HA", "HB1"},
824 : {"CB", "CT1"},
825 : {"HB", "HA1"},
826 : {"OG1", "OH1"},
827 : {"HG1", "H" },
828 : {"CG2", "CT3"},
829 : {"HG21", "HA3"},
830 : {"HG22", "HA3"},
831 : {"HG23", "HA3"},
832 : {"C", "C" },
833 : {"O", "O" }
834 80 : };
835 10 : typemap["TRP"] = {
836 : {"N", "NH1"},
837 : {"HN", "H" },
838 : {"CA", "CT1"},
839 : {"HA", "HB1"},
840 : {"CB", "CT2"},
841 : {"HB1", "HA2"},
842 : {"HB2", "HA2"},
843 : {"CG", "CY" },
844 : {"CD1", "CA" },
845 : {"HD1", "HP" },
846 : {"NE1", "NY" },
847 : {"HE1", "H" },
848 : {"CE2", "CPT"},
849 : {"CD2", "CPT"},
850 : {"CE3", "CAI"},
851 : {"HE3", "HP" },
852 : {"CZ3", "CA" },
853 : {"HZ3", "HP" },
854 : {"CZ2", "CAI"},
855 : {"HZ2", "HP" },
856 : {"CH2", "CA" },
857 : {"HH2", "HP" },
858 : {"C", "C" },
859 : {"O", "O" }
860 130 : };
861 10 : typemap["TYR"] = {
862 : {"N", "NH1"},
863 : {"HN", "H" },
864 : {"CA", "CT1"},
865 : {"HA", "HB1"},
866 : {"CB", "CT2"},
867 : {"HB1", "HA2"},
868 : {"HB2", "HA2"},
869 : {"CG", "CA" },
870 : {"CD1", "CA" },
871 : {"HD1", "HP" },
872 : {"CE1", "CA" },
873 : {"HE1", "HP" },
874 : {"CZ", "CA" },
875 : {"OH", "OH1"},
876 : {"HH", "H" },
877 : {"CD2", "CA" },
878 : {"HD2", "HP" },
879 : {"CE2", "CA" },
880 : {"HE2", "HP" },
881 : {"C", "C" },
882 : {"O", "O" }
883 115 : };
884 10 : typemap["VAL"] = {
885 : {"N", "NH1"},
886 : {"HN", "H" },
887 : {"CA", "CT1"},
888 : {"HA", "HB1"},
889 : {"CB", "CT1"},
890 : {"HB", "HA1"},
891 : {"CG1", "CT3"},
892 : {"HG11", "HA3"},
893 : {"HG12", "HA3"},
894 : {"HG13", "HA3"},
895 : {"CG2", "CT3"},
896 : {"HG21", "HA3"},
897 : {"HG22", "HA3"},
898 : {"HG23", "HA3"},
899 : {"C", "C" },
900 : {"O", "O" }
901 90 : };
902 5 : return typemap;
903 : }
904 :
905 5 : std::map<std::string, std::vector<double> > EEFSolv::setupValueMap() {
906 : // Volume ∆Gref ∆Gfree ∆H ∆Cp λ vdw_radius
907 : std::map<std::string, std::vector<double> > valuemap;
908 5 : valuemap["C"] = {
909 : ANG3_TO_NM3 * 14.720,
910 : KCAL_TO_KJ * 0.000,
911 : KCAL_TO_KJ * 0.000,
912 : KCAL_TO_KJ * 0.000,
913 : KCAL_TO_KJ * 0.0,
914 : 1. / (ANG_TO_NM * 3.5),
915 : 0.20,
916 10 : };
917 5 : valuemap["CD"] = {
918 : ANG3_TO_NM3 * 14.720,
919 : KCAL_TO_KJ * 0.000,
920 : KCAL_TO_KJ * 0.000,
921 : KCAL_TO_KJ * 0.000,
922 : KCAL_TO_KJ * 0.0,
923 : 1. / (ANG_TO_NM * 3.5),
924 : 0.20,
925 10 : };
926 5 : valuemap["CT1"] = {
927 : ANG3_TO_NM3 * 11.507,
928 : KCAL_TO_KJ * -0.187,
929 : KCAL_TO_KJ * -0.187,
930 : KCAL_TO_KJ * 0.876,
931 : KCAL_TO_KJ * 0.0,
932 : 1. / (ANG_TO_NM * 3.5),
933 : 0.20,
934 10 : };
935 5 : valuemap["CT2"] = {
936 : ANG3_TO_NM3 * 18.850,
937 : KCAL_TO_KJ * 0.372,
938 : KCAL_TO_KJ * 0.372,
939 : KCAL_TO_KJ * -0.610,
940 : KCAL_TO_KJ * 18.6,
941 : 1. / (ANG_TO_NM * 3.5),
942 : 0.20,
943 10 : };
944 5 : valuemap["CT2A"] = {
945 : ANG3_TO_NM3 * 18.666,
946 : KCAL_TO_KJ * 0.372,
947 : KCAL_TO_KJ * 0.372,
948 : KCAL_TO_KJ * -0.610,
949 : KCAL_TO_KJ * 18.6,
950 : 1. / (ANG_TO_NM * 3.5),
951 : 0.20,
952 10 : };
953 5 : valuemap["CT3"] = {
954 : ANG3_TO_NM3 * 27.941,
955 : KCAL_TO_KJ * 1.089,
956 : KCAL_TO_KJ * 1.089,
957 : KCAL_TO_KJ * -1.779,
958 : KCAL_TO_KJ * 35.6,
959 : 1. / (ANG_TO_NM * 3.5),
960 : 0.204,
961 10 : };
962 5 : valuemap["CPH1"] = {
963 : ANG3_TO_NM3 * 5.275,
964 : KCAL_TO_KJ * 0.057,
965 : KCAL_TO_KJ * 0.080,
966 : KCAL_TO_KJ * -0.973,
967 : KCAL_TO_KJ * 6.9,
968 : 1. / (ANG_TO_NM * 3.5),
969 : 0.18,
970 10 : };
971 5 : valuemap["CPH2"] = {
972 : ANG3_TO_NM3 * 11.796,
973 : KCAL_TO_KJ * 0.057,
974 : KCAL_TO_KJ * 0.080,
975 : KCAL_TO_KJ * -0.973,
976 : KCAL_TO_KJ * 6.9,
977 : 1. / (ANG_TO_NM * 3.5),
978 : 0.18,
979 10 : };
980 5 : valuemap["CPT"] = {
981 : ANG3_TO_NM3 * 4.669,
982 : KCAL_TO_KJ * -0.890,
983 : KCAL_TO_KJ * -0.890,
984 : KCAL_TO_KJ * 2.220,
985 : KCAL_TO_KJ * 6.9,
986 : 1. / (ANG_TO_NM * 3.5),
987 : 0.186,
988 10 : };
989 5 : valuemap["CY"] = {
990 : ANG3_TO_NM3 * 10.507,
991 : KCAL_TO_KJ * -0.890,
992 : KCAL_TO_KJ * -0.890,
993 : KCAL_TO_KJ * 2.220,
994 : KCAL_TO_KJ * 6.9,
995 : 1. / (ANG_TO_NM * 3.5),
996 : 0.199,
997 10 : };
998 5 : valuemap["CP1"] = {
999 : ANG3_TO_NM3 * 25.458,
1000 : KCAL_TO_KJ * -0.187,
1001 : KCAL_TO_KJ * -0.187,
1002 : KCAL_TO_KJ * 0.876,
1003 : KCAL_TO_KJ * 0.0,
1004 : 1. / (ANG_TO_NM * 3.5),
1005 : 0.227,
1006 10 : };
1007 5 : valuemap["CP2"] = {
1008 : ANG3_TO_NM3 * 19.880,
1009 : KCAL_TO_KJ * 0.372,
1010 : KCAL_TO_KJ * 0.372,
1011 : KCAL_TO_KJ * -0.610,
1012 : KCAL_TO_KJ * 18.6,
1013 : 1. / (ANG_TO_NM * 3.5),
1014 : 0.217,
1015 10 : };
1016 5 : valuemap["CP3"] = {
1017 : ANG3_TO_NM3 * 26.731,
1018 : KCAL_TO_KJ * 0.372,
1019 : KCAL_TO_KJ * 0.372,
1020 : KCAL_TO_KJ * -0.610,
1021 : KCAL_TO_KJ * 18.6,
1022 : 1. / (ANG_TO_NM * 3.5),
1023 : 0.217,
1024 10 : };
1025 5 : valuemap["CC"] = {
1026 : ANG3_TO_NM3 * 16.539,
1027 : KCAL_TO_KJ * 0.000,
1028 : KCAL_TO_KJ * 0.000,
1029 : KCAL_TO_KJ * 0.000,
1030 : KCAL_TO_KJ * 0.0,
1031 : 1. / (ANG_TO_NM * 3.5),
1032 : 0.20,
1033 10 : };
1034 5 : valuemap["CAI"] = {
1035 : ANG3_TO_NM3 * 18.249,
1036 : KCAL_TO_KJ * 0.057,
1037 : KCAL_TO_KJ * 0.057,
1038 : KCAL_TO_KJ * -0.973,
1039 : KCAL_TO_KJ * 6.9,
1040 : 1. / (ANG_TO_NM * 3.5),
1041 : 0.199,
1042 10 : };
1043 5 : valuemap["CA"] = {
1044 : ANG3_TO_NM3 * 18.249,
1045 : KCAL_TO_KJ * 0.057,
1046 : KCAL_TO_KJ * 0.057,
1047 : KCAL_TO_KJ * -0.973,
1048 : KCAL_TO_KJ * 6.9,
1049 : 1. / (ANG_TO_NM * 3.5),
1050 : 0.199,
1051 10 : };
1052 5 : valuemap["N"] = {
1053 : ANG3_TO_NM3 * 0.000,
1054 : KCAL_TO_KJ * -1.000,
1055 : KCAL_TO_KJ * -1.000,
1056 : KCAL_TO_KJ * -1.250,
1057 : KCAL_TO_KJ * 8.8,
1058 : 1. / (ANG_TO_NM * 3.5),
1059 : 0.185,
1060 10 : };
1061 5 : valuemap["NR1"] = {
1062 : ANG3_TO_NM3 * 15.273,
1063 : KCAL_TO_KJ * -5.950,
1064 : KCAL_TO_KJ * -5.950,
1065 : KCAL_TO_KJ * -9.059,
1066 : KCAL_TO_KJ * -8.8,
1067 : 1. / (ANG_TO_NM * 3.5),
1068 : 0.185,
1069 10 : };
1070 5 : valuemap["NR2"] = {
1071 : ANG3_TO_NM3 * 15.111,
1072 : KCAL_TO_KJ * -3.820,
1073 : KCAL_TO_KJ * -3.820,
1074 : KCAL_TO_KJ * -4.654,
1075 : KCAL_TO_KJ * -8.8,
1076 : 1. / (ANG_TO_NM * 3.5),
1077 : 0.185,
1078 10 : };
1079 5 : valuemap["NR3"] = {
1080 : ANG3_TO_NM3 * 15.071,
1081 : KCAL_TO_KJ * -5.950,
1082 : KCAL_TO_KJ * -5.950,
1083 : KCAL_TO_KJ * -9.059,
1084 : KCAL_TO_KJ * -8.8,
1085 : 1. / (ANG_TO_NM * 3.5),
1086 : 0.185,
1087 10 : };
1088 5 : valuemap["NH1"] = {
1089 : ANG3_TO_NM3 * 10.197,
1090 : KCAL_TO_KJ * -5.950,
1091 : KCAL_TO_KJ * -5.950,
1092 : KCAL_TO_KJ * -9.059,
1093 : KCAL_TO_KJ * -8.8,
1094 : 1. / (ANG_TO_NM * 3.5),
1095 : 0.185,
1096 10 : };
1097 5 : valuemap["NH2"] = {
1098 : ANG3_TO_NM3 * 18.182,
1099 : KCAL_TO_KJ * -5.950,
1100 : KCAL_TO_KJ * -5.950,
1101 : KCAL_TO_KJ * -9.059,
1102 : KCAL_TO_KJ * -8.8,
1103 : 1. / (ANG_TO_NM * 3.5),
1104 : 0.185,
1105 10 : };
1106 5 : valuemap["NH3"] = {
1107 : ANG3_TO_NM3 * 18.817,
1108 : KCAL_TO_KJ * -20.000,
1109 : KCAL_TO_KJ * -20.000,
1110 : KCAL_TO_KJ * -25.000,
1111 : KCAL_TO_KJ * -18.0,
1112 : 1. / (ANG_TO_NM * 6.0),
1113 : 0.185,
1114 10 : };
1115 5 : valuemap["NC2"] = {
1116 : ANG3_TO_NM3 * 18.215,
1117 : KCAL_TO_KJ * -10.000,
1118 : KCAL_TO_KJ * -10.000,
1119 : KCAL_TO_KJ * -12.000,
1120 : KCAL_TO_KJ * -7.0,
1121 : 1. / (ANG_TO_NM * 6.0),
1122 : 0.185,
1123 10 : };
1124 5 : valuemap["NY"] = {
1125 : ANG3_TO_NM3 * 12.001,
1126 : KCAL_TO_KJ * -5.950,
1127 : KCAL_TO_KJ * -5.950,
1128 : KCAL_TO_KJ * -9.059,
1129 : KCAL_TO_KJ * -8.8,
1130 : 1. / (ANG_TO_NM * 3.5),
1131 : 0.185,
1132 10 : };
1133 5 : valuemap["NP"] = {
1134 : ANG3_TO_NM3 * 4.993,
1135 : KCAL_TO_KJ * -20.000,
1136 : KCAL_TO_KJ * -20.000,
1137 : KCAL_TO_KJ * -25.000,
1138 : KCAL_TO_KJ * -18.0,
1139 : 1. / (ANG_TO_NM * 6.0),
1140 : 0.185,
1141 10 : };
1142 5 : valuemap["O"] = {
1143 : ANG3_TO_NM3 * 11.772,
1144 : KCAL_TO_KJ * -5.330,
1145 : KCAL_TO_KJ * -5.330,
1146 : KCAL_TO_KJ * -5.787,
1147 : KCAL_TO_KJ * -8.8,
1148 : 1. / (ANG_TO_NM * 3.5),
1149 : 0.170,
1150 10 : };
1151 5 : valuemap["OB"] = {
1152 : ANG3_TO_NM3 * 11.694,
1153 : KCAL_TO_KJ * -5.330,
1154 : KCAL_TO_KJ * -5.330,
1155 : KCAL_TO_KJ * -5.787,
1156 : KCAL_TO_KJ * -8.8,
1157 : 1. / (ANG_TO_NM * 3.5),
1158 : 0.170,
1159 10 : };
1160 5 : valuemap["OC"] = {
1161 : ANG3_TO_NM3 * 12.003,
1162 : KCAL_TO_KJ * -10.000,
1163 : KCAL_TO_KJ * -10.000,
1164 : KCAL_TO_KJ * -12.000,
1165 : KCAL_TO_KJ * -9.4,
1166 : 1. / (ANG_TO_NM * 6.0),
1167 : 0.170,
1168 10 : };
1169 5 : valuemap["OH1"] = {
1170 : ANG3_TO_NM3 * 15.528,
1171 : KCAL_TO_KJ * -5.920,
1172 : KCAL_TO_KJ * -5.920,
1173 : KCAL_TO_KJ * -9.264,
1174 : KCAL_TO_KJ * -11.2,
1175 : 1. / (ANG_TO_NM * 3.5),
1176 : 0.177,
1177 10 : };
1178 5 : valuemap["OS"] = {
1179 : ANG3_TO_NM3 * 6.774,
1180 : KCAL_TO_KJ * -2.900,
1181 : KCAL_TO_KJ * -2.900,
1182 : KCAL_TO_KJ * -3.150,
1183 : KCAL_TO_KJ * -4.8,
1184 : 1. / (ANG_TO_NM * 3.5),
1185 : 0.177,
1186 10 : };
1187 5 : valuemap["S"] = {
1188 : ANG3_TO_NM3 * 20.703,
1189 : KCAL_TO_KJ * -3.240,
1190 : KCAL_TO_KJ * -3.240,
1191 : KCAL_TO_KJ * -4.475,
1192 : KCAL_TO_KJ * -39.9,
1193 : 1. / (ANG_TO_NM * 3.5),
1194 : 0.20,
1195 10 : };
1196 5 : valuemap["SM"] = {
1197 : ANG3_TO_NM3 * 21.306,
1198 : KCAL_TO_KJ * -3.240,
1199 : KCAL_TO_KJ * -3.240,
1200 : KCAL_TO_KJ * -4.475,
1201 : KCAL_TO_KJ * -39.9,
1202 : 1. / (ANG_TO_NM * 3.5),
1203 : 0.197,
1204 10 : };
1205 5 : return valuemap;
1206 : }
1207 : }
1208 : }
|
