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