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