18 #if defined(DEAL_II_WITH_ADOLC) || defined(DEAL_II_TRILINOS_WITH_SACADO)
33 # ifdef DEAL_II_WITH_ADOLC
36 # include <adolc/adolc_fatalerror.h>
37 # include <adolc/drivers/drivers.h>
38 # include <adolc/taping.h>
56 template <
typename ADNumberType,
typename ScalarType,
typename T>
65 template <
typename ADNumberType,
typename ScalarType,
typename T>
74 template <
typename ADNumberType,
typename ScalarType,
typename T>
84 template <
typename ADNumberType,
typename ScalarType,
typename T>
93 template <
typename ADNumberType,
typename ScalarType,
typename T>
105 template <
typename ADNumberType,
typename ScalarType,
typename T>
115 template <
typename ADNumberType,
typename ScalarType,
typename T>
125 template <
typename ADNumberType,
typename ScalarType,
typename T>
126 std::vector<typename Types<ADNumberType>::tape_index>
131 return std::vector<typename Types<ADNumberType>::tape_index>();
135 template <
typename ADNumberType,
typename ScalarType,
typename T>
144 template <
typename ADNumberType,
typename ScalarType,
typename T>
154 template <
typename ADNumberType,
typename ScalarType,
typename T>
164 template <
typename ADNumberType,
typename ScalarType,
typename T>
173 template <
typename ADNumberType,
typename ScalarType,
typename T>
181 template <
typename ADNumberType,
typename ScalarType,
typename T>
189 template <
typename ADNumberType,
typename ScalarType,
typename T>
193 std::ostream &)
const
199 template <
typename ADNumberType,
typename ScalarType,
typename T>
203 const std::vector<ScalarType> &)
const
206 return ScalarType(0.0);
210 template <
typename ADNumberType,
typename ScalarType,
typename T>
214 const std::vector<ScalarType> &,
221 template <
typename ADNumberType,
typename ScalarType,
typename T>
225 const std::vector<ScalarType> &,
232 template <
typename ADNumberType,
typename ScalarType,
typename T>
237 const std::vector<ScalarType> &,
244 template <
typename ADNumberType,
typename ScalarType,
typename T>
249 const std::vector<ScalarType> &,
257 # ifdef DEAL_II_WITH_ADOLC
262 template <
typename ADNumberType>
265 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
267 : active_tape(
Numbers<ADNumberType>::invalid_tape_index)
269 , is_recording_flag(false)
270 , use_stored_taped_buffer_sizes(false)
279 template <
typename ADNumberType>
283 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
287 return is_recording_flag;
291 template <
typename ADNumberType>
296 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
303 template <
typename ADNumberType>
305 TapedDrivers<ADNumberType,
307 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
309 keep_independent_values()
const
315 template <
typename ADNumberType>
319 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
366 const std::vector<typename Types<ADNumberType>::tape_index>
367 registered_tape_indices = get_registered_tape_indices();
368 const auto it = std::find(registered_tape_indices.begin(),
369 registered_tape_indices.end(),
371 if (it == registered_tape_indices.end())
377 std::vector<std::size_t> counts(STAT_SIZE);
378 ::tapestats(tape_index, counts.data());
381 catch (const ::FatalError &exc)
388 template <
typename ADNumberType>
392 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
394 set_tape_buffer_sizes(
402 obufsize = in_obufsize;
403 lbufsize = in_lbufsize;
404 vbufsize = in_vbufsize;
405 tbufsize = in_tbufsize;
406 use_stored_taped_buffer_sizes =
true;
410 template <
typename ADNumberType>
414 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
417 const bool keep_independent_values)
419 if (use_stored_taped_buffer_sizes)
421 keep_independent_values,
427 trace_on(tape_index, keep_independent_values);
430 keep_values = keep_independent_values;
431 is_recording_flag =
true;
435 template <
typename ADNumberType>
439 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
443 const bool write_tapes_to_file)
445 if (write_tapes_to_file)
446 trace_off(active_tape_index);
452 is_recording_flag =
false;
458 if (keep_independent_values() ==
false)
463 template <
typename ADNumberType>
464 std::vector<typename Types<ADNumberType>::tape_index>
467 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
469 get_registered_tape_indices()
const
475 std::vector<short> registered_tape_indices_s;
476 cachedTraceTags(registered_tape_indices_s);
478 return std::vector<typename Types<ADNumberType>::tape_index>(
479 registered_tape_indices_s.begin(), registered_tape_indices_s.end());
483 template <
typename ADNumberType>
487 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
491 active_tape = tape_index;
495 template <
typename ADNumberType>
499 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
505 is_registered_tape(tape_index) ==
true,
507 "Cannot ask for the status of a tape that has not yet been recorded and used."));
509 const auto it_status_tape = status.find(tape_index);
521 if (it_status_tape == status.end())
524 const auto status_tape = it_status_tape->second;
529 status_tape < 4 && status_tape >= -2,
531 "The tape status is not within the range specified within the ADOL-C documentation."));
532 return (status_tape < 0);
536 template <
typename ADNumberType>
538 TapedDrivers<ADNumberType,
540 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
542 last_action_requires_retaping()
const
544 return requires_retaping(active_tape);
548 template <
typename ADNumberType>
552 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
556 Assert(is_registered_tape(tape_index),
558 "This tape does not exist, and therefore cannot be cleared."));
559 removeTape(tape_index, TapeRemovalType::ADOLC_REMOVE_COMPLETELY);
563 template <
typename ADNumberType>
567 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
569 reset(
const bool clear_registered_tapes)
572 is_recording_flag =
false;
574 if (clear_registered_tapes)
576 const std::vector<typename Types<ADNumberType>::tape_index>
577 registered_tape_indices = get_registered_tape_indices();
578 for (
const auto &tape_index : registered_tape_indices)
579 remove_tape(tape_index);
584 template <
typename ADNumberType>
586 TapedDrivers<ADNumberType,
588 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
593 const std::vector<typename Types<ADNumberType>::tape_index>
594 registered_tape_indices = get_registered_tape_indices();
595 stream <<
"Registered tapes and their status: ";
596 auto it_registered_tape = registered_tape_indices.begin();
597 for (
unsigned int i = 0; i < registered_tape_indices.size();
598 ++i, ++it_registered_tape)
600 const auto tape_index = *it_registered_tape;
601 const auto it_status_tape = status.find(tape_index);
602 Assert(it_status_tape != status.end(),
604 "This tape's status has not been found in the map."));
605 const auto status_tape = it_status_tape->second;
607 stream << tape_index <<
"->" << status_tape
608 << (i < (registered_tape_indices.size() - 1) ?
"," :
"");
612 stream <<
"Keep values? " << keep_independent_values() <<
'\n';
613 stream <<
"Use stored tape buffer sizes? "
614 << use_stored_taped_buffer_sizes <<
'\n';
618 template <
typename ADNumberType>
620 TapedDrivers<ADNumberType,
622 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
626 std::ostream & stream)
const
630 std::vector<std::size_t> counts(STAT_SIZE);
631 ::tapestats(tape_index, counts.data());
634 <<
"Tape index: " << tape_index <<
'\n'
635 <<
"Number of independent variables: " << counts[0] <<
'\n'
636 <<
"Number of dependent variables: " << counts[1] <<
'\n'
637 <<
"Max number of live, active variables: " << counts[2] <<
'\n'
638 <<
"Size of taylor stack (number of overwrites): " << counts[3] <<
'\n'
639 <<
"Operations buffer size: " << counts[4] <<
'\n'
640 <<
"Total number of recorded operations: " << counts[5] <<
'\n'
641 <<
"Operations file written or not: " << counts[6] <<
'\n'
642 <<
"Overall number of locations: " << counts[7] <<
'\n'
643 <<
"Locations file written or not: " << counts[8] <<
'\n'
644 <<
"Overall number of values: " << counts[9] <<
'\n'
645 <<
"Values file written or not: " << counts[10] <<
'\n'
646 <<
"Locations buffer size: " << counts[11] <<
'\n'
647 <<
"Values buffer size: " << counts[12] <<
'\n'
648 <<
"Taylor buffer size: " << counts[13] <<
'\n'
649 <<
"Number of eq_*_prod for sparsity pattern: " << counts[14] <<
'\n'
650 <<
"Use of 'min_op', deferred to 'abs_op' for piecewise calculations: "
651 << counts[15] <<
'\n'
652 <<
"Number of 'abs' calls that can switch branch: " << counts[16]
654 <<
"Number of parameters (doubles) interchangeable without retaping: "
655 << counts[17] <<
'\n'
660 template <
typename ADNumberType>
664 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
668 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
671 const std::vector<scalar_type> &independent_variables)
const
673 Assert(is_registered_tape(active_tape_index),
674 ExcMessage(
"This tape has not yet been recorded."));
676 scalar_type value = 0.0;
678 status[active_tape_index] =
679 ::function(active_tape_index,
681 independent_variables.size(),
682 const_cast<double *
>(independent_variables.data()),
689 template <
typename ADNumberType>
693 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
696 const std::vector<scalar_type> &independent_variables,
704 Assert(gradient.size() == independent_variables.size(),
706 independent_variables.size()));
707 Assert(is_registered_tape(active_tape_index),
708 ExcMessage(
"This tape has not yet been recorded."));
713 status[active_tape_index] =
714 ::gradient(active_tape_index,
715 independent_variables.size(),
716 const_cast<scalar_type *
>(independent_variables.data()),
721 template <
typename ADNumberType>
723 TapedDrivers<ADNumberType,
725 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
728 const std::vector<scalar_type> &independent_variables,
736 Assert(hessian.m() == independent_variables.size(),
738 Assert(hessian.n() == independent_variables.size(),
740 Assert(is_registered_tape(active_tape_index),
741 ExcMessage(
"This tape has not yet been recorded."));
743 const unsigned int n_independent_variables = independent_variables.size();
744 std::vector<scalar_type *> H(n_independent_variables);
745 for (
unsigned int i = 0; i < n_independent_variables; ++i)
746 H[i] = &hessian[i][0];
748 status[active_tape_index] =
749 ::hessian(active_tape_index,
750 n_independent_variables,
751 const_cast<scalar_type *
>(independent_variables.data()),
757 for (
unsigned int i = 0; i < n_independent_variables; ++i)
758 for (
unsigned int j = 0; j < i; ++j)
759 hessian[j][i] = hessian[i][j];
763 template <
typename ADNumberType>
765 TapedDrivers<ADNumberType,
767 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
770 const unsigned int n_dependent_variables,
771 const std::vector<scalar_type> &independent_variables,
776 Assert(is_registered_tape(active_tape_index),
777 ExcMessage(
"This tape has not yet been recorded."));
782 status[active_tape_index] =
783 ::function(active_tape_index,
784 n_dependent_variables,
785 independent_variables.size(),
786 const_cast<scalar_type *
>(independent_variables.data()),
791 template <
typename ADNumberType>
793 TapedDrivers<ADNumberType,
795 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
798 const unsigned int n_dependent_variables,
799 const std::vector<scalar_type> &independent_variables,
802 Assert(AD::ADNumberTraits<ADNumberType>::n_supported_derivative_levels >=
805 AD::ADNumberTraits<ADNumberType>::n_supported_derivative_levels,
807 Assert(jacobian.
m() == n_dependent_variables,
809 Assert(jacobian.
n() == independent_variables.size(),
811 Assert(is_registered_tape(active_tape_index),
812 ExcMessage(
"This tape has not yet been recorded."));
814 std::vector<scalar_type *> J(n_dependent_variables);
815 for (
unsigned int i = 0; i < n_dependent_variables; ++i)
816 J[i] = &jacobian[i][0];
818 status[active_tape_index] = ::jacobian(active_tape_index,
819 n_dependent_variables,
820 independent_variables.size(),
821 independent_variables.data(),
829 template <
typename ADNumberType>
831 TapedDrivers<ADNumberType,
833 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
842 template <
typename ADNumberType>
847 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
855 template <
typename ADNumberType>
857 TapedDrivers<ADNumberType,
859 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
861 keep_independent_values()
const
868 template <
typename ADNumberType>
870 TapedDrivers<ADNumberType,
872 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
881 template <
typename ADNumberType>
883 TapedDrivers<ADNumberType,
885 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
887 set_tape_buffer_sizes(
897 template <
typename ADNumberType>
899 TapedDrivers<ADNumberType,
901 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
909 template <
typename ADNumberType>
911 TapedDrivers<ADNumberType,
913 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
921 template <
typename ADNumberType>
922 std::vector<typename Types<ADNumberType>::tape_index>
923 TapedDrivers<ADNumberType,
925 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
927 get_registered_tape_indices()
const
930 return std::vector<typename Types<ADNumberType>::tape_index>();
934 template <
typename ADNumberType>
936 TapedDrivers<ADNumberType,
938 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
946 template <
typename ADNumberType>
948 TapedDrivers<ADNumberType,
950 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
959 template <
typename ADNumberType>
961 TapedDrivers<ADNumberType,
963 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
965 last_action_requires_retaping()
const
972 template <
typename ADNumberType>
974 TapedDrivers<ADNumberType,
976 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
984 template <
typename ADNumberType>
986 TapedDrivers<ADNumberType,
988 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
995 template <
typename ADNumberType>
997 TapedDrivers<ADNumberType,
999 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1007 template <
typename ADNumberType>
1009 TapedDrivers<ADNumberType,
1011 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1014 std::ostream &)
const
1020 template <
typename ADNumberType>
1021 typename TapedDrivers<
1024 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1026 TapedDrivers<ADNumberType,
1028 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1031 const std::vector<scalar_type> &)
const
1038 template <
typename ADNumberType>
1040 TapedDrivers<ADNumberType,
1042 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1045 const std::vector<scalar_type> &,
1052 template <
typename ADNumberType>
1054 TapedDrivers<ADNumberType,
1056 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1059 const std::vector<scalar_type> &,
1066 template <
typename ADNumberType>
1068 TapedDrivers<ADNumberType,
1070 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1074 const std::vector<scalar_type> &,
1081 template <
typename ADNumberType>
1083 TapedDrivers<ADNumberType,
1085 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1089 const std::vector<scalar_type> &,
1101 template <
typename ADNumberType>
1103 TapedDrivers<ADNumberType,
1105 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1111 return taped_driver.is_recording();
1115 template <
typename ADNumberType>
1120 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1125 return taped_driver.active_tape_index();
1129 template <
typename ADNumberType>
1131 TapedDrivers<ADNumberType,
1133 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1135 keep_independent_values()
const
1137 return taped_driver.keep_independent_values();
1141 template <
typename ADNumberType>
1143 TapedDrivers<ADNumberType,
1145 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1152 return taped_driver.is_registered_tape(tape_index);
1156 template <
typename ADNumberType>
1158 TapedDrivers<ADNumberType,
1160 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1162 set_tape_buffer_sizes(
1170 taped_driver.set_tape_buffer_sizes(obufsize,
1177 template <
typename ADNumberType>
1179 TapedDrivers<ADNumberType,
1181 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1184 const bool keep_independent_values)
1188 taped_driver.start_taping(tape_index, keep_independent_values);
1192 template <
typename ADNumberType>
1194 TapedDrivers<ADNumberType,
1196 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1200 const bool write_tapes_to_file)
1204 taped_driver.stop_taping(active_tape_index, write_tapes_to_file);
1208 template <
typename ADNumberType>
1209 std::vector<typename Types<ADNumberType>::tape_index>
1210 TapedDrivers<ADNumberType,
1212 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1214 get_registered_tape_indices()
const
1216 return taped_driver.get_registered_tape_indices();
1220 template <
typename ADNumberType>
1222 TapedDrivers<ADNumberType,
1224 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1228 taped_driver.activate_tape(tape_index);
1232 template <
typename ADNumberType>
1234 TapedDrivers<ADNumberType,
1236 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1241 return taped_driver.requires_retaping(tape_index);
1245 template <
typename ADNumberType>
1247 TapedDrivers<ADNumberType,
1249 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1251 last_action_requires_retaping()
const
1253 return taped_driver.last_action_requires_retaping();
1257 template <
typename ADNumberType>
1259 TapedDrivers<ADNumberType,
1261 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1265 taped_driver.remove_tape(tape_index);
1269 template <
typename ADNumberType>
1271 TapedDrivers<ADNumberType,
1273 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1275 reset(
const bool clear_registered_tapes)
1277 taped_driver.reset(clear_registered_tapes);
1281 template <
typename ADNumberType>
1283 TapedDrivers<ADNumberType,
1285 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1290 taped_driver.print(stream);
1294 template <
typename ADNumberType>
1296 TapedDrivers<ADNumberType,
1298 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1302 std::ostream & stream)
const
1306 taped_driver.print_tape_stats(tape_index, stream);
1310 template <
typename ADNumberType>
1311 typename TapedDrivers<
1314 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1316 TapedDrivers<ADNumberType,
1318 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1321 const std::vector<scalar_type> &independent_variables)
const
1325 return taped_driver.value(active_tape_index,
1326 vector_float_to_double(independent_variables));
1330 template <
typename ADNumberType>
1332 TapedDrivers<ADNumberType,
1334 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1337 const std::vector<scalar_type> &independent_variables,
1343 taped_driver.gradient(active_tape_index,
1344 vector_float_to_double(independent_variables),
1350 template <
typename ADNumberType>
1352 TapedDrivers<ADNumberType,
1354 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1357 const std::vector<scalar_type> &independent_variables,
1363 taped_driver.hessian(active_tape_index,
1364 vector_float_to_double(independent_variables),
1370 template <
typename ADNumberType>
1372 TapedDrivers<ADNumberType,
1374 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1377 const unsigned int n_dependent_variables,
1378 const std::vector<scalar_type> &independent_variables,
1384 taped_driver.values(active_tape_index,
1385 n_dependent_variables,
1386 vector_float_to_double(independent_variables),
1392 template <
typename ADNumberType>
1394 TapedDrivers<ADNumberType,
1396 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1399 const unsigned int n_dependent_variables,
1400 const std::vector<scalar_type> &independent_variables,
1406 taped_driver.jacobian(active_tape_index,
1407 n_dependent_variables,
1408 vector_float_to_double(independent_variables),
1410 jacobian = jacobian_double;
1415 template <
typename ADNumberType>
1417 TapedDrivers<ADNumberType,
1419 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1421 vector_float_to_double(
const std::vector<float> &in)
const
1423 std::vector<double> out(in.size());
1424 std::copy(in.begin(), in.end(), out.begin());
1433 template <
typename ADNumberType,
typename ScalarType,
typename T>
1441 template <
typename ADNumberType,
typename ScalarType,
typename T>
1449 template <
typename ADNumberType,
typename ScalarType,
typename T>
1457 template <
typename ADNumberType,
typename ScalarType,
typename T>
1467 template <
typename ADNumberType,
typename ScalarType,
typename T>
1470 const std::vector<ADNumberType> &)
const
1473 return ScalarType(0.0);
1477 template <
typename ADNumberType,
typename ScalarType,
typename T>
1480 const std::vector<ADNumberType> &,
1481 const std::vector<ADNumberType> &,
1488 template <
typename ADNumberType,
typename ScalarType,
typename T>
1491 const std::vector<ADNumberType> &,
1492 const std::vector<ADNumberType> &,
1499 template <
typename ADNumberType,
typename ScalarType,
typename T>
1502 const std::vector<ADNumberType> &,
1509 template <
typename ADNumberType,
typename ScalarType,
typename T>
1512 const std::vector<ADNumberType> &,
1513 const std::vector<ADNumberType> &,
1526 template <
typename ADNumberType>
1534 # ifdef DEAL_II_TRILINOS_WITH_SACADO
1545 template <
typename ADNumberType>
1550 ADNumberType &dependent_variable)
1560 ADNumberType::Outvar_Gradcomp(dependent_variable);
1570 template <
typename ADNumberType>
1577 # ifdef DEAL_II_WITH_ADOLC
1587 template <
typename ADNumberType>
1588 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1592 # ifdef DEAL_II_ADOLC_WITH_TAPELESS_REFCOUNTING
1607 const std::size_t n_live_variables = adtl::refcounter::getNumLiveVar();
1608 if (n_live_variables == 0)
1610 adtl::setNumDir(n_directional_derivatives);
1619 const std::size_t n_set_directional_derivatives = adtl::getNumDir();
1620 if (n_directional_derivatives > n_set_directional_derivatives)
1622 n_live_variables == 0,
1626 "adtl::adouble variables in existence. They currently "
1629 " directional derivatives "
1630 "but you wish to increase this to " +
1633 "To safely change (or more specifically in this case, "
1634 "increase) the number of directional derivatives, there "
1635 "must be no tapeless doubles in local/global scope."));
1641 adtl::setNumDir(n_directional_derivatives);
1647 template <
typename ADNumberType>
1648 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1666 template <
typename ADNumberType,
typename ScalarType>
1670 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1672 ADNumberTraits<ADNumberType>::type_code ==
1674 : dependent_variable_marking_safe(false)
1679 template <
typename ADNumberType,
typename ScalarType>
1681 TapelessDrivers<ADNumberType,
1683 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1685 ADNumberTraits<ADNumberType>::type_code ==
1687 initialize_global_environment(
const unsigned int n_independent_variables)
1689 internal::configure_tapeless_mode<ADNumberType>(n_independent_variables);
1693 template <
typename ADNumberType,
typename ScalarType>
1700 ADNumberTraits<ADNumberType>::type_code ==
1703 dependent_variable_marking_safe =
true;
1707 template <
typename ADNumberType,
typename ScalarType>
1714 ADNumberTraits<ADNumberType>::type_code ==
1717 dependent_variable_marking_safe =
false;
1721 template <
typename ADNumberType,
typename ScalarType>
1723 TapelessDrivers<ADNumberType,
1725 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1727 ADNumberTraits<ADNumberType>::type_code ==
1729 is_dependent_variable_marking_allowed()
const
1731 return dependent_variable_marking_safe;
1735 template <
typename ADNumberType,
typename ScalarType>
1737 TapelessDrivers<ADNumberType,
1739 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1741 ADNumberTraits<ADNumberType>::type_code ==
1743 value(
const std::vector<ADNumberType> &dependent_variables)
const
1745 Assert(dependent_variables.size() == 1,
1747 return ADNumberTraits<ADNumberType>::get_scalar_value(
1748 dependent_variables[0]);
1752 template <
typename ADNumberType,
typename ScalarType>
1754 TapelessDrivers<ADNumberType,
1756 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1758 ADNumberTraits<ADNumberType>::type_code ==
1760 gradient(
const std::vector<ADNumberType> &independent_variables,
1761 const std::vector<ADNumberType> &dependent_variables,
1764 Assert(AD::ADNumberTraits<ADNumberType>::n_supported_derivative_levels >=
1767 AD::ADNumberTraits<ADNumberType>::n_supported_derivative_levels,
1769 Assert(dependent_variables.size() == 1,
1773 independent_variables.size()));
1778 const_cast<ADNumberType &
>(dependent_variables[0]));
1779 const std::size_t n_independent_variables = independent_variables.size();
1780 for (
unsigned int i = 0; i < n_independent_variables; ++i)
1782 ADNumberTraits<ADNumberType>::get_directional_derivative(
1783 independent_variables[i], 0 ));
1787 template <
typename ADNumberType,
typename ScalarType>
1789 TapelessDrivers<ADNumberType,
1791 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1793 ADNumberTraits<ADNumberType>::type_code ==
1795 hessian(
const std::vector<ADNumberType> &independent_variables,
1796 const std::vector<ADNumberType> &dependent_variables,
1799 Assert(AD::ADNumberTraits<ADNumberType>::n_supported_derivative_levels >=
1802 AD::ADNumberTraits<ADNumberType>::n_supported_derivative_levels,
1804 Assert(dependent_variables.size() == 1,
1814 const_cast<ADNumberType &
>(dependent_variables[0]));
1815 const std::size_t n_independent_variables = independent_variables.size();
1816 for (
unsigned int i = 0; i < n_independent_variables; ++i)
1818 using derivative_type =
1819 typename ADNumberTraits<ADNumberType>::derivative_type;
1820 const derivative_type gradient_i =
1821 ADNumberTraits<ADNumberType>::get_directional_derivative(
1822 independent_variables[i], i);
1824 for (
unsigned int j = 0; j <= i; ++j)
1829 const ScalarType hessian_ij =
1831 ADNumberTraits<derivative_type>::get_directional_derivative(
1841 template <
typename ADNumberType,
typename ScalarType>
1843 TapelessDrivers<ADNumberType,
1845 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1847 ADNumberTraits<ADNumberType>::type_code ==
1849 values(
const std::vector<ADNumberType> &dependent_variables,
1855 const std::size_t n_dependent_variables = dependent_variables.size();
1856 for (
unsigned int i = 0; i < n_dependent_variables; ++i)
1857 values[i] = ADNumberTraits<ADNumberType>::get_scalar_value(
1858 dependent_variables[i]);
1862 template <
typename ADNumberType,
typename ScalarType>
1864 TapelessDrivers<ADNumberType,
1866 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1868 ADNumberTraits<ADNumberType>::type_code ==
1870 jacobian(
const std::vector<ADNumberType> &independent_variables,
1871 const std::vector<ADNumberType> &dependent_variables,
1874 Assert(AD::ADNumberTraits<ADNumberType>::n_supported_derivative_levels >=
1877 AD::ADNumberTraits<ADNumberType>::n_supported_derivative_levels,
1879 Assert(jacobian.
m() == dependent_variables.size(),
1881 Assert(jacobian.
n() == independent_variables.size(),
1884 const std::size_t n_independent_variables = independent_variables.size();
1885 const std::size_t n_dependent_variables = dependent_variables.size();
1896 using accumulation_type =
1897 typename ADNumberTraits<ADNumberType>::derivative_type;
1898 std::vector<accumulation_type> rad_accumulation(
1899 n_independent_variables,
1902 for (
unsigned int i = 0; i < n_dependent_variables; ++i)
1905 const_cast<ADNumberType &
>(dependent_variables[i]));
1906 for (
unsigned int j = 0; j < n_independent_variables; ++j)
1908 const accumulation_type df_i_dx_j =
1909 ADNumberTraits<ADNumberType>::get_directional_derivative(
1910 independent_variables[j],
1912 rad_accumulation[j];
1915 rad_accumulation[j] += df_i_dx_j;
1927 template <
typename ADNumberType,
typename ScalarType>
1931 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1933 ADNumberTraits<ADNumberType>::type_code ==
1935 ADNumberTraits<ADNumberType>::type_code ==
1937 : dependent_variable_marking_safe(false)
1942 template <
typename ADNumberType,
typename ScalarType>
1944 TapelessDrivers<ADNumberType,
1946 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1948 ADNumberTraits<ADNumberType>::type_code ==
1950 ADNumberTraits<ADNumberType>::type_code ==
1952 initialize_global_environment(
const unsigned int n_independent_variables)
1954 internal::configure_tapeless_mode<ADNumberType>(n_independent_variables);
1958 template <
typename ADNumberType,
typename ScalarType>
1964 ADNumberTraits<ADNumberType>::type_code ==
1967 ADNumberTraits<ADNumberType>::type_code ==
1970 dependent_variable_marking_safe =
true;
1974 template <
typename ADNumberType,
typename ScalarType>
1980 ADNumberTraits<ADNumberType>::type_code ==
1983 ADNumberTraits<ADNumberType>::type_code ==
1986 dependent_variable_marking_safe =
false;
1990 template <
typename ADNumberType,
typename ScalarType>
1992 TapelessDrivers<ADNumberType,
1994 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
1996 ADNumberTraits<ADNumberType>::type_code ==
1998 ADNumberTraits<ADNumberType>::type_code ==
2000 is_dependent_variable_marking_allowed()
const
2002 return dependent_variable_marking_safe;
2006 template <
typename ADNumberType,
typename ScalarType>
2008 TapelessDrivers<ADNumberType,
2010 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
2012 ADNumberTraits<ADNumberType>::type_code ==
2014 ADNumberTraits<ADNumberType>::type_code ==
2016 value(
const std::vector<ADNumberType> &dependent_variables)
const
2018 Assert(dependent_variables.size() == 1,
2020 return ADNumberTraits<ADNumberType>::get_scalar_value(
2021 dependent_variables[0]);
2025 template <
typename ADNumberType,
typename ScalarType>
2027 TapelessDrivers<ADNumberType,
2029 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
2031 ADNumberTraits<ADNumberType>::type_code ==
2033 ADNumberTraits<ADNumberType>::type_code ==
2035 gradient(
const std::vector<ADNumberType> &independent_variables,
2036 const std::vector<ADNumberType> &dependent_variables,
2039 Assert(AD::ADNumberTraits<ADNumberType>::n_supported_derivative_levels >=
2042 AD::ADNumberTraits<ADNumberType>::n_supported_derivative_levels,
2044 Assert(dependent_variables.size() == 1,
2048 independent_variables.size()));
2052 const std::size_t n_independent_variables = independent_variables.size();
2053 for (
unsigned int i = 0; i < n_independent_variables; ++i)
2055 ADNumberTraits<ADNumberType>::get_directional_derivative(
2056 dependent_variables[0], i));
2060 template <
typename ADNumberType,
typename ScalarType>
2062 TapelessDrivers<ADNumberType,
2064 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
2066 ADNumberTraits<ADNumberType>::type_code ==
2068 ADNumberTraits<ADNumberType>::type_code ==
2070 hessian(
const std::vector<ADNumberType> &independent_variables,
2071 const std::vector<ADNumberType> &dependent_variables,
2074 Assert(AD::ADNumberTraits<ADNumberType>::n_supported_derivative_levels >=
2077 AD::ADNumberTraits<ADNumberType>::n_supported_derivative_levels,
2079 Assert(dependent_variables.size() == 1,
2088 const std::size_t n_independent_variables = independent_variables.size();
2089 for (
unsigned int i = 0; i < n_independent_variables; ++i)
2091 using derivative_type =
2092 typename ADNumberTraits<ADNumberType>::derivative_type;
2093 const derivative_type gradient_i =
2094 ADNumberTraits<ADNumberType>::get_directional_derivative(
2095 dependent_variables[0], i);
2097 for (
unsigned int j = 0; j <= i; ++j)
2102 const ScalarType hessian_ij =
2104 ADNumberTraits<derivative_type>::get_directional_derivative(
2114 template <
typename ADNumberType,
typename ScalarType>
2116 TapelessDrivers<ADNumberType,
2118 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
2120 ADNumberTraits<ADNumberType>::type_code ==
2122 ADNumberTraits<ADNumberType>::type_code ==
2124 values(
const std::vector<ADNumberType> &dependent_variables,
2130 const std::size_t n_dependent_variables = dependent_variables.size();
2131 for (
unsigned int i = 0; i < n_dependent_variables; ++i)
2132 values[i] = ADNumberTraits<ADNumberType>::get_scalar_value(
2133 dependent_variables[i]);
2137 template <
typename ADNumberType,
typename ScalarType>
2139 TapelessDrivers<ADNumberType,
2141 std::enable_if_t<ADNumberTraits<ADNumberType>::type_code ==
2143 ADNumberTraits<ADNumberType>::type_code ==
2145 ADNumberTraits<ADNumberType>::type_code ==
2147 jacobian(
const std::vector<ADNumberType> &independent_variables,
2148 const std::vector<ADNumberType> &dependent_variables,
2151 Assert(AD::ADNumberTraits<ADNumberType>::n_supported_derivative_levels >=
2154 AD::ADNumberTraits<ADNumberType>::n_supported_derivative_levels,
2156 Assert(jacobian.
m() == dependent_variables.size(),
2158 Assert(jacobian.
n() == independent_variables.size(),
2161 const std::size_t n_independent_variables = independent_variables.size();
2162 const std::size_t n_dependent_variables = dependent_variables.size();
2166 for (
unsigned int i = 0; i < n_dependent_variables; ++i)
2167 for (
unsigned int j = 0; j < n_independent_variables; ++j)
2169 ADNumberTraits<ADNumberType>::get_directional_derivative(
2170 dependent_variables[i], j));
2179 # include "ad_drivers.inst"
2180 # ifdef DEAL_II_WITH_ADOLC
2181 # include "ad_drivers.inst1"
2183 # ifdef DEAL_II_TRILINOS_WITH_SACADO
2184 # include "ad_drivers.inst2"
#define DEAL_II_NAMESPACE_OPEN
#define DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
#define DEAL_II_NAMESPACE_CLOSE
#define DEAL_II_ENABLE_EXTRA_DIAGNOSTICS
static ::ExceptionBase & ExcRequiresADOLC()
static ::ExceptionBase & ExcInternalError()
static ::ExceptionBase & ExcDimensionMismatch(std::size_t arg1, std::size_t arg2)
#define Assert(cond, exc)
static ::ExceptionBase & ExcSupportedDerivativeLevels(std::size_t arg1, std::size_t arg2)
static ::ExceptionBase & ExcRequiresADNumberSpecialization()
static ::ExceptionBase & ExcMessage(std::string arg1)
#define AssertThrow(cond, exc)
std::enable_if_t<!(ADNumberTraits< ADNumberType >::type_code==NumberTypes::sacado_rad||ADNumberTraits< ADNumberType >::type_code==NumberTypes::sacado_rad_dfad)> reverse_mode_dependent_variable_activation(ADNumberType &)
std::enable_if_t<!(ADNumberTraits< ADNumberType >::type_code==NumberTypes::adolc_tapeless)> configure_tapeless_mode(const unsigned int)
void copy(const T *begin, const T *end, U *dest)
static const Types< ADNumberType >::tape_index invalid_tape_index
void gradient(const typename Types< ADNumberType >::tape_index active_tape_index, const std::vector< ScalarType > &independent_variables, Vector< ScalarType > &gradient) const
bool is_recording() const
bool is_registered_tape(const typename Types< ADNumberType >::tape_index tape_index) const
void stop_taping(const typename Types< ADNumberType >::tape_index active_tape_index, const bool write_tapes_to_file)
void remove_tape(const typename Types< ADNumberType >::tape_index tape_index)
void start_taping(const typename Types< ADNumberType >::tape_index tape_index, const bool keep_independent_values)
void hessian(const typename Types< ADNumberType >::tape_index active_tape_index, const std::vector< ScalarType > &independent_variables, FullMatrix< ScalarType > &hessian) const
void set_tape_buffer_sizes(const typename Types< ADNumberType >::tape_buffer_sizes obufsize=64 *1024 *1024, const typename Types< ADNumberType >::tape_buffer_sizes lbufsize=64 *1024 *1024, const typename Types< ADNumberType >::tape_buffer_sizes vbufsize=64 *1024 *1024, const typename Types< ADNumberType >::tape_buffer_sizes tbufsize=64 *1024 *1024)
void activate_tape(const typename Types< ADNumberType >::tape_index tape_index)
bool last_action_requires_retaping() const
bool requires_retaping(const typename Types< ADNumberType >::tape_index tape_index) const
void print(std::ostream &stream) const
void print_tape_stats(const typename Types< ADNumberType >::tape_index tape_index, std::ostream &stream) const
ScalarType value(const typename Types< ADNumberType >::tape_index active_tape_index, const std::vector< ScalarType > &independent_variables) const
bool keep_independent_values() const
Types< ADNumberType >::tape_index active_tape_index() const
void reset(const bool clear_registered_tapes)
std::vector< typename Types< ADNumberType >::tape_index > get_registered_tape_indices() const
void values(const typename Types< ADNumberType >::tape_index active_tape_index, const unsigned int n_dependent_variables, const std::vector< ScalarType > &independent_variables, Vector< ScalarType > &values) const
void jacobian(const typename Types< ADNumberType >::tape_index active_tape_index, const unsigned int n_dependent_variables, const std::vector< ScalarType > &independent_variables, FullMatrix< ScalarType > &jacobian) const
void gradient(const std::vector< ADNumberType > &independent_variables, const std::vector< ADNumberType > &dependent_variables, Vector< ScalarType > &gradient) const
void allow_dependent_variable_marking()
void hessian(const std::vector< ADNumberType > &independent_variables, const std::vector< ADNumberType > &dependent_variables, FullMatrix< ScalarType > &hessian) const
void values(const std::vector< ADNumberType > &dependent_variables, Vector< ScalarType > &values) const
void jacobian(const std::vector< ADNumberType > &independent_variables, const std::vector< ADNumberType > &dependent_variables, FullMatrix< ScalarType > &jacobian) const
static void initialize_global_environment(const unsigned int n_independent_variables)
bool is_dependent_variable_marking_allowed() const
ScalarType value(const std::vector< ADNumberType > &dependent_variables) const
void prevent_dependent_variable_marking()
unsigned int tape_buffer_sizes
static constexpr const T & value(const T &t)