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