ESPResSo
Extensible Simulation Package for Research on Soft Matter Systems
Loading...
Searching...
No Matches
BondedInteraction.hpp
Go to the documentation of this file.
1/*
2 * Copyright (C) 2021-2022 The ESPResSo project
3 *
4 * This file is part of ESPResSo.
5 *
6 * ESPResSo is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * ESPResSo is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20#pragma once
21
22/** @file
23 * The ScriptInterface counterparts of the bonded interactions parameters
24 * structs from the core are defined here.
25 *
26 */
27
30#include "core/thermostat.hpp"
31
35
36#include <boost/algorithm/string/predicate.hpp>
37#include <boost/variant.hpp>
38
39#include <algorithm>
40#include <cassert>
41#include <cmath>
42#include <cstddef>
43#include <iterator>
44#include <limits>
45#include <memory>
46#include <set>
47#include <stdexcept>
48#include <string>
49#include <tuple>
50#include <utility>
51#include <vector>
52
53namespace ScriptInterface {
54namespace Interactions {
55
56class BondedInteraction : public AutoParameters<BondedInteraction> {
57protected:
58 std::shared_ptr<::Bonded_IA_Parameters> m_bonded_ia;
59
60public:
61 std::shared_ptr<::Bonded_IA_Parameters> bonded_ia() { return m_bonded_ia; }
62 std::shared_ptr<const ::Bonded_IA_Parameters> bonded_ia() const {
63 return m_bonded_ia;
64 }
65
66protected:
69
70 virtual std::set<std::string> get_valid_parameters() const {
71 auto const vec = valid_parameters();
72 auto valid_keys = std::set<std::string>();
73 std::transform(vec.begin(), vec.end(),
74 std::inserter(valid_keys, valid_keys.begin()),
75 [](auto const &key) { return std::string{key}; });
76 return valid_keys;
77 }
78
79private:
80 void check_valid_parameters(VariantMap const &params) const {
81 auto const valid_keys = get_valid_parameters();
82 for (auto const &key : valid_keys) {
83 if (not params.contains(std::string(key))) {
84 throw std::runtime_error("Parameter '" + key + "' is missing");
85 }
86 }
87 for (auto const &kv : params) {
88 if (not valid_keys.contains(kv.first)) {
89 throw std::runtime_error("Parameter '" + kv.first +
90 "' is not recognized");
91 }
92 }
93 }
94
95 void do_construct(VariantMap const &params) override {
96 context()->parallel_try_catch([&]() {
97 check_valid_parameters(params);
98 construct_bond(params);
99 });
100 }
101
102 virtual void construct_bond(VariantMap const &params) = 0;
103
104public:
105 bool operator==(BondedInteraction const &other) const {
106 return m_bonded_ia == other.m_bonded_ia;
107 }
108
109 Variant do_call_method(std::string const &name,
110 VariantMap const &params) override {
111 // this feature is needed to compare bonds
112 if (name == "is_same_bond") {
113 auto const bond_so =
115 return *this == *bond_so;
116 }
117 if (name == "get_num_partners") {
118 return number_of_partners(*bonded_ia());
119 }
120
121 return {};
122 }
123};
124
125template <class CoreIA> class BondedInteractionImpl : public BondedInteraction {
126public:
127 using CoreBondedInteraction = CoreIA;
129 return boost::get<CoreBondedInteraction>(*bonded_ia());
130 }
131};
132
133class FeneBond : public BondedInteractionImpl<::FeneBond> {
134public:
136 add_parameters({
137 {"k", AutoParameter::read_only, [this]() { return get_struct().k; }},
138 {"d_r_max", AutoParameter::read_only,
139 [this]() { return get_struct().drmax; }},
140 {"r_0", AutoParameter::read_only, [this]() { return get_struct().r0; }},
141 });
142 }
143
144private:
145 void construct_bond(VariantMap const &params) override {
146 m_bonded_ia = std::make_shared<::Bonded_IA_Parameters>(
147 CoreBondedInteraction(get_value<double>(params, "k"),
148 get_value<double>(params, "d_r_max"),
149 get_value<double>(params, "r_0")));
150 }
151};
152
153class HarmonicBond : public BondedInteractionImpl<::HarmonicBond> {
154public:
156 add_parameters({
157 {"k", AutoParameter::read_only, [this]() { return get_struct().k; }},
158 {"r_0", AutoParameter::read_only, [this]() { return get_struct().r; }},
159 {"r_cut", AutoParameter::read_only,
160 [this]() { return get_struct().r_cut; }},
161 });
162 }
163
164private:
165 void construct_bond(VariantMap const &params) override {
166 m_bonded_ia =
167 std::make_shared<::Bonded_IA_Parameters>(CoreBondedInteraction(
168 get_value<double>(params, "k"), get_value<double>(params, "r_0"),
169 get_value<double>(params, "r_cut")));
170 }
171};
172
173class QuarticBond : public BondedInteractionImpl<::QuarticBond> {
174public:
176 add_parameters({
177 {"k0", AutoParameter::read_only, [this]() { return get_struct().k0; }},
178 {"k1", AutoParameter::read_only, [this]() { return get_struct().k1; }},
179 {"r", AutoParameter::read_only, [this]() { return get_struct().r; }},
180 {"r_cut", AutoParameter::read_only,
181 [this]() { return get_struct().r_cut; }},
182 });
183 }
184
185private:
186 void construct_bond(VariantMap const &params) override {
187 m_bonded_ia =
188 std::make_shared<::Bonded_IA_Parameters>(CoreBondedInteraction(
189 get_value<double>(params, "k0"), get_value<double>(params, "k1"),
190 get_value<double>(params, "r"),
191 get_value<double>(params, "r_cut")));
192 }
193};
194
195class BondedCoulomb : public BondedInteractionImpl<::BondedCoulomb> {
196public:
198 add_parameters({
199 {"prefactor", AutoParameter::read_only,
200 [this]() { return get_struct().prefactor; }},
201 });
202 }
203
204private:
205 void construct_bond(VariantMap const &params) override {
206 m_bonded_ia = std::make_shared<::Bonded_IA_Parameters>(
207 CoreBondedInteraction(get_value<double>(params, "prefactor")));
208 }
209};
210
211class BondedCoulombSR : public BondedInteractionImpl<::BondedCoulombSR> {
212public:
214 add_parameters({
215 {"q1q2", AutoParameter::read_only,
216 [this]() { return get_struct().q1q2; }},
217 });
218 }
219
220private:
221 void construct_bond(VariantMap const &params) override {
222 m_bonded_ia = std::make_shared<::Bonded_IA_Parameters>(
223 CoreBondedInteraction(get_value<double>(params, "q1q2")));
224 }
225};
226
227class AngleHarmonicBond : public BondedInteractionImpl<::AngleHarmonicBond> {
228public:
230 add_parameters({
231 {"bend", AutoParameter::read_only,
232 [this]() { return get_struct().bend; }},
233 {"phi0", AutoParameter::read_only,
234 [this]() { return get_struct().phi0; }},
235 });
236 }
237
238private:
239 void construct_bond(VariantMap const &params) override {
240 m_bonded_ia = std::make_shared<::Bonded_IA_Parameters>(
241 CoreBondedInteraction(get_value<double>(params, "bend"),
242 get_value<double>(params, "phi0")));
243 }
244};
245
246class AngleCosineBond : public BondedInteractionImpl<::AngleCosineBond> {
247public:
249 add_parameters({
250 {"bend", AutoParameter::read_only,
251 [this]() { return get_struct().bend; }},
252 {"phi0", AutoParameter::read_only,
253 [this]() { return get_struct().phi0; }},
254 });
255 }
256
257private:
258 void construct_bond(VariantMap const &params) override {
259 m_bonded_ia = std::make_shared<::Bonded_IA_Parameters>(
260 CoreBondedInteraction(get_value<double>(params, "bend"),
261 get_value<double>(params, "phi0")));
262 }
263};
264
265class AngleCossquareBond : public BondedInteractionImpl<::AngleCossquareBond> {
266public:
268 add_parameters({
269 {"bend", AutoParameter::read_only,
270 [this]() { return get_struct().bend; }},
271 {"phi0", AutoParameter::read_only,
272 [this]() { return get_struct().phi0; }},
273 });
274 }
275
276private:
277 void construct_bond(VariantMap const &params) override {
278 m_bonded_ia = std::make_shared<::Bonded_IA_Parameters>(
279 CoreBondedInteraction(get_value<double>(params, "bend"),
280 get_value<double>(params, "phi0")));
281 }
282};
283
284class DihedralBond : public BondedInteractionImpl<::DihedralBond> {
285public:
287 add_parameters({
288 {"mult", AutoParameter::read_only,
289 [this]() { return get_struct().mult; }},
290 {"bend", AutoParameter::read_only,
291 [this]() { return get_struct().bend; }},
292 {"phase", AutoParameter::read_only,
293 [this]() { return get_struct().phase; }},
294 });
295 }
296
297private:
298 void construct_bond(VariantMap const &params) override {
299 m_bonded_ia =
300 std::make_shared<::Bonded_IA_Parameters>(CoreBondedInteraction(
301 get_value<int>(params, "mult"), get_value<double>(params, "bend"),
302 get_value<double>(params, "phase")));
303 }
304};
305
307 : public BondedInteractionImpl<::TabulatedDistanceBond> {
308public:
310 add_parameters({
311 {"min", AutoParameter::read_only,
312 [this]() { return get_struct().pot->minval; }},
313 {"max", AutoParameter::read_only,
314 [this]() { return get_struct().pot->maxval; }},
315 {"energy", AutoParameter::read_only,
316 [this]() { return get_struct().pot->energy_tab; }},
317 {"force", AutoParameter::read_only,
318 [this]() { return get_struct().pot->force_tab; }},
319 });
320 }
321
322private:
323 void construct_bond(VariantMap const &params) override {
324 m_bonded_ia =
325 std::make_shared<::Bonded_IA_Parameters>(CoreBondedInteraction(
326 get_value<double>(params, "min"), get_value<double>(params, "max"),
327 get_value<std::vector<double>>(params, "energy"),
328 get_value<std::vector<double>>(params, "force")));
329 }
330};
331
332class TabulatedAngleBond : public BondedInteractionImpl<::TabulatedAngleBond> {
333public:
335 add_parameters({
336 {"min", AutoParameter::read_only,
337 [this]() { return get_struct().pot->minval; }},
338 {"max", AutoParameter::read_only,
339 [this]() { return get_struct().pot->maxval; }},
340 {"energy", AutoParameter::read_only,
341 [this]() { return get_struct().pot->energy_tab; }},
342 {"force", AutoParameter::read_only,
343 [this]() { return get_struct().pot->force_tab; }},
344 });
345 }
346
347private:
348 void construct_bond(VariantMap const &params) override {
349 m_bonded_ia =
350 std::make_shared<::Bonded_IA_Parameters>(CoreBondedInteraction(
351 get_value<double>(params, "min"), get_value<double>(params, "max"),
352 get_value<std::vector<double>>(params, "energy"),
353 get_value<std::vector<double>>(params, "force")));
354 }
355};
356
358 : public BondedInteractionImpl<::TabulatedDihedralBond> {
359public:
361 add_parameters({
362 {"min", AutoParameter::read_only,
363 [this]() { return get_struct().pot->minval; }},
364 {"max", AutoParameter::read_only,
365 [this]() { return get_struct().pot->maxval; }},
366 {"energy", AutoParameter::read_only,
367 [this]() { return get_struct().pot->energy_tab; }},
368 {"force", AutoParameter::read_only,
369 [this]() { return get_struct().pot->force_tab; }},
370 });
371 }
372
373private:
374 void construct_bond(VariantMap const &params) override {
375 m_bonded_ia =
376 std::make_shared<::Bonded_IA_Parameters>(CoreBondedInteraction(
377 get_value<double>(params, "min"), get_value<double>(params, "max"),
378 get_value<std::vector<double>>(params, "energy"),
379 get_value<std::vector<double>>(params, "force")));
380 }
381};
382
383class ThermalizedBond : public BondedInteractionImpl<::ThermalizedBond> {
384public:
386 add_parameters({
387 {"temp_com", AutoParameter::read_only,
388 [this]() { return get_struct().temp_com; }},
389 {"gamma_com", AutoParameter::read_only,
390 [this]() { return get_struct().gamma_com; }},
391 {"temp_distance", AutoParameter::read_only,
392 [this]() { return get_struct().temp_distance; }},
393 {"gamma_distance", AutoParameter::read_only,
394 [this]() { return get_struct().gamma_distance; }},
395 {"r_cut", AutoParameter::read_only,
396 [this]() { return get_struct().r_cut; }},
397 });
398 }
399
400private:
401 void construct_bond(VariantMap const &params) override {
402 m_bonded_ia = std::make_shared<::Bonded_IA_Parameters>(
403 CoreBondedInteraction(get_value<double>(params, "temp_com"),
404 get_value<double>(params, "gamma_com"),
405 get_value<double>(params, "temp_distance"),
406 get_value<double>(params, "gamma_distance"),
407 get_value<double>(params, "r_cut")));
408 }
409};
410
411class RigidBond : public BondedInteractionImpl<::RigidBond> {
412public:
414 add_parameters({
415 {"r", AutoParameter::read_only,
416 [this]() { return std::sqrt(get_struct().d2); }},
417 {"ptol", AutoParameter::read_only,
418 [this]() { return 0.5 * get_struct().p_tol; }},
419 {"vtol", AutoParameter::read_only,
420 [this]() { return get_struct().v_tol; }},
421 });
422 }
423
424private:
425 void construct_bond(VariantMap const &params) override {
426 m_bonded_ia =
427 std::make_shared<::Bonded_IA_Parameters>(CoreBondedInteraction(
428 get_value<double>(params, "r"), get_value<double>(params, "ptol"),
429 get_value<double>(params, "vtol")));
430 }
431};
432
433class IBMTriel : public BondedInteractionImpl<::IBMTriel> {
434public:
436 add_parameters({
437 {"k1", AutoParameter::read_only, [this]() { return get_struct().k1; }},
438 {"k2", AutoParameter::read_only, [this]() { return get_struct().k2; }},
439 {"ind1", AutoParameter::read_only,
440 [this]() { return std::get<0>(get_struct().p_ids); }},
441 {"ind2", AutoParameter::read_only,
442 [this]() { return std::get<1>(get_struct().p_ids); }},
443 {"ind3", AutoParameter::read_only,
444 [this]() { return std::get<2>(get_struct().p_ids); }},
445 {"maxDist", AutoParameter::read_only,
446 [this]() { return get_struct().maxDist; }},
447 {"elasticLaw", AutoParameter::read_only,
448 [this]() {
449 if (get_struct().elasticLaw == tElasticLaw::NeoHookean) {
450 return std::string("NeoHookean");
451 }
452 return std::string("Skalak");
453 }},
454 {"is_initialized", AutoParameter::read_only,
455 [this]() { return get_struct().is_initialized; }},
456 {"_cache", AutoParameter::read_only,
457 [this]() {
458 auto &s = get_struct();
459 return std::vector<double>{{s.l0, s.lp0, s.sinPhi0, s.cosPhi0,
460 s.area0, s.a1, s.a2, s.b1, s.b2}};
461 }},
462 });
463 }
464
465private:
466 void construct_bond(VariantMap const &params) override {
467 auto const law_name = get_value<std::string>(params, "elasticLaw");
468 tElasticLaw elastic_law;
469 if (law_name == "NeoHookean") {
470 elastic_law = tElasticLaw::NeoHookean;
471 } else if (law_name == "Skalak") {
472 elastic_law = tElasticLaw::Skalak;
473 } else {
474 throw std::invalid_argument(
475 "Invalid value for parameter 'elasticLaw': '" + law_name + "'");
476 }
477 auto bond = CoreBondedInteraction(
478 get_value<int>(params, "ind1"), get_value<int>(params, "ind2"),
479 get_value<int>(params, "ind3"), get_value<double>(params, "maxDist"),
480 elastic_law, get_value<double>(params, "k1"),
481 get_value<double>(params, "k2"));
482 if (get_value_or<bool>(params, "is_initialized", false)) {
483 auto const cache = get_value<std::vector<double>>(params, "_cache");
484 assert(cache.size() == 9ul);
485 bond.l0 = cache[0];
486 bond.lp0 = cache[1];
487 bond.sinPhi0 = cache[2];
488 bond.cosPhi0 = cache[3];
489 bond.area0 = cache[4];
490 bond.a1 = cache[5];
491 bond.a2 = cache[6];
492 bond.b1 = cache[7];
493 bond.b2 = cache[8];
494 bond.is_initialized = true;
495 }
496 m_bonded_ia = std::make_shared<::Bonded_IA_Parameters>(std::move(bond));
497 }
498};
499
500class IBMVolCons : public BondedInteractionImpl<::IBMVolCons> {
501public:
503 add_parameters({
504 {"softID", AutoParameter::read_only,
505 [this]() { return static_cast<int>(get_struct().softID); }},
506 {"kappaV", AutoParameter::read_only,
507 [this]() { return get_struct().kappaV; }},
508 });
509 }
510
511 Variant do_call_method(std::string const &name,
512 VariantMap const &params) override {
513 if (name == "current_volume") {
514 return get_struct().get_current_volume();
515 }
516 return BondedInteraction::do_call_method(name, params);
517 }
518
519private:
520 void construct_bond(VariantMap const &params) override {
521 m_bonded_ia = std::make_shared<::Bonded_IA_Parameters>(
522 CoreBondedInteraction(get_value<int>(params, "softID"),
523 get_value<double>(params, "kappaV")));
524 }
525};
526
527class IBMTribend : public BondedInteractionImpl<::IBMTribend> {
528public:
530 add_parameters({
531 {"kb", AutoParameter::read_only, [this]() { return get_struct().kb; }},
532 {"ind1", AutoParameter::read_only,
533 [this]() { return std::get<0>(get_struct().p_ids); }},
534 {"ind2", AutoParameter::read_only,
535 [this]() { return std::get<1>(get_struct().p_ids); }},
536 {"ind3", AutoParameter::read_only,
537 [this]() { return std::get<2>(get_struct().p_ids); }},
538 {"ind4", AutoParameter::read_only,
539 [this]() { return std::get<3>(get_struct().p_ids); }},
540 {"refShape", AutoParameter::read_only,
541 [this]() {
542 return std::string((get_struct().flat) ? "Flat" : "Initial");
543 }},
544 {"theta0", AutoParameter::read_only,
545 [this]() { return get_struct().theta0; }},
546 {"is_initialized", AutoParameter::read_only,
547 [this]() { return get_struct().is_initialized; }},
548 });
549 }
550
551private:
552 void construct_bond(VariantMap const &params) override {
553 auto const shape_name = get_value<std::string>(params, "refShape");
554 bool flat;
555 if (shape_name == "Flat") {
556 flat = true;
557 } else if (shape_name == "Initial") {
558 flat = false;
559 } else {
560 throw std::invalid_argument("Invalid value for parameter 'refShape': '" +
561 shape_name + "'");
562 }
563 auto bond = CoreBondedInteraction(
564 get_value<int>(params, "ind1"), get_value<int>(params, "ind2"),
565 get_value<int>(params, "ind3"), get_value<int>(params, "ind4"),
566 get_value<double>(params, "kb"), flat);
567 if (get_value_or<bool>(params, "is_initialized", false)) {
568 bond.theta0 = get_value<double>(params, "theta0");
569 bond.is_initialized = true;
570 }
571 m_bonded_ia = std::make_shared<::Bonded_IA_Parameters>(std::move(bond));
572 }
573};
574
576 : public BondedInteractionImpl<::OifGlobalForcesBond> {
577public:
579 add_parameters({
580 {"A0_g", AutoParameter::read_only,
581 [this]() { return get_struct().A0_g; }},
582 {"ka_g", AutoParameter::read_only,
583 [this]() { return get_struct().ka_g; }},
584 {"V0", AutoParameter::read_only, [this]() { return get_struct().V0; }},
585 {"kv", AutoParameter::read_only, [this]() { return get_struct().kv; }},
586 });
587 }
588
589private:
590 void construct_bond(VariantMap const &params) override {
591 m_bonded_ia =
592 std::make_shared<::Bonded_IA_Parameters>(CoreBondedInteraction(
593 get_value<double>(params, "A0_g"),
594 get_value<double>(params, "ka_g"), get_value<double>(params, "V0"),
595 get_value<double>(params, "kv")));
596 }
597};
598
599class OifLocalForcesBond : public BondedInteractionImpl<::OifLocalForcesBond> {
600public:
602 add_parameters({
603 {"r0", AutoParameter::read_only, [this]() { return get_struct().r0; }},
604 {"ks", AutoParameter::read_only, [this]() { return get_struct().ks; }},
605 {"kslin", AutoParameter::read_only,
606 [this]() { return get_struct().kslin; }},
607 {"phi0", AutoParameter::read_only,
608 [this]() { return get_struct().phi0; }},
609 {"kb", AutoParameter::read_only, [this]() { return get_struct().kb; }},
610 {"A01", AutoParameter::read_only,
611 [this]() { return get_struct().A01; }},
612 {"A02", AutoParameter::read_only,
613 [this]() { return get_struct().A02; }},
614 {"kal", AutoParameter::read_only,
615 [this]() { return get_struct().kal; }},
616 {"kvisc", AutoParameter::read_only,
617 [this]() { return get_struct().kvisc; }},
618 });
619 }
620
621private:
622 void construct_bond(VariantMap const &params) override {
623 m_bonded_ia =
624 std::make_shared<::Bonded_IA_Parameters>(CoreBondedInteraction(
625 get_value<double>(params, "r0"), get_value<double>(params, "ks"),
626 get_value<double>(params, "kslin"),
627 get_value<double>(params, "phi0"), get_value<double>(params, "kb"),
628 get_value<double>(params, "A01"), get_value<double>(params, "A02"),
629 get_value<double>(params, "kal"),
630 get_value<double>(params, "kvisc")));
631 }
632};
633
634class VirtualBond : public BondedInteractionImpl<::VirtualBond> {
635public:
637 m_bonded_ia =
638 std::make_shared<::Bonded_IA_Parameters>(CoreBondedInteraction());
639 }
640
641private:
642 void construct_bond(VariantMap const &) override {}
643};
644
645} // namespace Interactions
646} // namespace ScriptInterface
Data structures for bonded interactions.
int number_of_partners(Bonded_IA_Parameters const &iaparams)
Get the number of bonded partners for the specified bond.
Bind parameters in the script interface.
std::span< const boost::string_ref > valid_parameters() const final
void construct_bond(VariantMap const &params) override
void construct_bond(VariantMap const &params) override
void construct_bond(VariantMap const &params) override
void construct_bond(VariantMap const &params) override
void construct_bond(VariantMap const &params) override
virtual std::set< std::string > get_valid_parameters() const
std::shared_ptr<::Bonded_IA_Parameters > m_bonded_ia
bool operator==(BondedInteraction const &other) const
std::shared_ptr< const ::Bonded_IA_Parameters > bonded_ia() const
void do_construct(VariantMap const &params) override
virtual void construct_bond(VariantMap const &params)=0
std::shared_ptr<::Bonded_IA_Parameters > bonded_ia()
Variant do_call_method(std::string const &name, VariantMap const &params) override
void construct_bond(VariantMap const &params) override
void construct_bond(VariantMap const &params) override
void construct_bond(VariantMap const &params) override
void construct_bond(VariantMap const &params) override
void construct_bond(VariantMap const &params) override
Variant do_call_method(std::string const &name, VariantMap const &params) override
void construct_bond(VariantMap const &params) override
void construct_bond(VariantMap const &params) override
void construct_bond(VariantMap const &params) override
void construct_bond(VariantMap const &params) override
void construct_bond(VariantMap const &params) override
void construct_bond(VariantMap const &params) override
void construct_bond(VariantMap const &params) override
void construct_bond(VariantMap const &params) override
void construct_bond(VariantMap const &params) override
void construct_bond(VariantMap const &) override
Context * context() const
Responsible context.
Implementation in thermostat.cpp.
tElasticLaw
Definition ibm_triel.hpp:32
T get_value(Variant const &v)
Extract value of specific type T from a Variant.
std::unordered_map< std::string, Variant > VariantMap
Definition Variant.hpp:69
boost::make_recursive_variant< None, bool, int, std::size_t, double, std::string, ObjectRef, Utils::Vector3b, Utils::Vector3i, Utils::Vector2d, Utils::Vector3d, Utils::Vector4d, std::vector< int >, std::vector< double >, std::vector< boost::recursive_variant_ >, std::unordered_map< int, boost::recursive_variant_ >, std::unordered_map< std::string, boost::recursive_variant_ > >::type Variant
Possible types for parameters.
Definition Variant.hpp:67
static SteepestDescentParameters params
Currently active steepest descent instance.