Reference documentation for deal.II version 9.1.1
\(\newcommand{\dealcoloneq}{\mathrel{\vcenter{:}}=}\)
scratch_data.h
1 // ---------------------------------------------------------------------
2 //
3 // Copyright (C) 2019 by the deal.II authors
4 //
5 // This file is part of the deal.II library.
6 //
7 // The deal.II library is free software; you can use it, redistribute
8 // it, and/or modify it under the terms of the GNU Lesser General
9 // Public License as published by the Free Software Foundation; either
10 // version 2.1 of the License, or (at your option) any later version.
11 // The full text of the license can be found in the file LICENSE.md at
12 // the top level directory of deal.II.
13 //
14 // ---------------------------------------------------------------------
15 
16 #ifndef dealii_meshworker_scratch_data_h
17 #define dealii_meshworker_scratch_data_h
18 
19 #include <deal.II/base/config.h>
20 
21 #include <deal.II/algorithms/general_data_storage.h>
22 
23 #include <deal.II/differentiation/ad.h>
24 
25 #include <deal.II/fe/fe_values.h>
26 #include <deal.II/fe/mapping_q1.h>
27 
28 #include <boost/any.hpp>
29 
30 #include <algorithm>
31 #include <map>
32 #include <vector>
33 
34 DEAL_II_NAMESPACE_OPEN
35 
36 namespace MeshWorker
37 {
38  namespace internal
39  {
44  template <int dim, int spacedim, typename NumberType, typename Extractor>
45  using OutputType = typename FEValuesViews::View<dim, spacedim, Extractor>::
46  template OutputType<NumberType>;
47  } // namespace internal
48 
231  template <int dim, int spacedim = dim>
233  {
234  public:
254  ScratchData(
257  const Quadrature<dim> & quadrature,
258  const UpdateFlags & update_flags,
261 
278  ScratchData(
281  const Quadrature<dim> & quadrature,
282  const UpdateFlags & update_flags,
283  const UpdateFlags & neighbor_update_flags,
287 
300  ScratchData(
302  const Quadrature<dim> & quadrature,
303  const UpdateFlags & update_flags,
306 
321  ScratchData(
323  const Quadrature<dim> & quadrature,
324  const UpdateFlags & update_flags,
325  const UpdateFlags & neighbor_update_flags,
329 
333  ScratchData(const ScratchData<dim, spacedim> &scratch);
334  // CurrentCellMethods
340 
349  reinit(
351 
361  const unsigned int face_no);
362 
375  const unsigned int face_no,
376  const unsigned int subface_no);
377 
389  get_current_fe_values() const;
390 
394  const std::vector<Point<spacedim>> &
395  get_quadrature_points() const;
396 
400  const std::vector<double> &
401  get_JxW_values() const;
402 
406  const std::vector<Tensor<1, spacedim>> &
407  get_normal_vectors() const;
408 
413  const std::vector<types::global_dof_index> &
414  get_local_dof_indices() const;
415  // CurrentCellMethods
417  // NeighborCellMethods
422 
433 
444  const unsigned int face_no);
445 
459  const unsigned int face_no,
460  const unsigned int subface_no);
461 
475 
479  const std::vector<double> &
480  get_neighbor_JxW_values() const;
481 
485  const std::vector<Tensor<1, spacedim>> &
487 
492  const std::vector<types::global_dof_index> &
493  get_neighbor_dof_indices() const;
494  // NeighborCellMethods
496 
504  // CurrentCellEvaluation
509 
539  template <typename VectorType, typename Number = double>
540  void
541  extract_local_dof_values(const std::string &global_vector_name,
542  const VectorType & input_vector,
543  const Number dummy = Number(0));
544 
553  template <typename Number = double>
554  const std::vector<Number> &
555  get_local_dof_values(const std::string &global_vector_name,
556  Number dummy = Number(0)) const;
557 
579  template <typename Extractor, typename Number = double>
580  const std::vector<
581  typename internal::OutputType<dim, spacedim, Number, Extractor>::
582  value_type> &
583  get_values(const std::string &global_vector_name,
584  const Extractor & variable,
585  const Number dummy = Number(0));
586 
608  template <typename Extractor, typename Number = double>
609  const std::vector<
610  typename internal::OutputType<dim, spacedim, Number, Extractor>::
611  gradient_type> &
612  get_gradients(const std::string &global_vector_name,
613  const Extractor & variable,
614  const Number dummy = Number(0));
615 
638  template <typename Extractor, typename Number = double>
639  const std::vector<
640  typename internal::OutputType<dim, spacedim, Number, Extractor>::
641  symmetric_gradient_type> &
642  get_symmetric_gradients(const std::string &global_vector_name,
643  const Extractor & variable,
644  const Number dummy = Number(0));
645 
667  template <typename Extractor, typename Number = double>
668  const std::vector<
669  typename internal::OutputType<dim, spacedim, Number, Extractor>::
670  divergence_type> &
671  get_divergences(const std::string &global_vector_name,
672  const Extractor & variable,
673  const Number dummy = Number(0));
674 
696  template <typename Extractor, typename Number = double>
697  const std::vector<typename internal::
698  OutputType<dim, spacedim, Number, Extractor>::curl_type>
699  &
700  get_curls(const std::string &global_vector_name,
701  const Extractor & variable,
702  const Number dummy = Number(0));
703 
725  template <typename Extractor, typename Number = double>
726  const std::vector<
727  typename internal::OutputType<dim, spacedim, Number, Extractor>::
728  hessian_type> &
729  get_hessians(const std::string &global_vector_name,
730  const Extractor & variable,
731  const Number dummy = Number(0));
732 
754  template <typename Extractor, typename Number = double>
755  const std::vector<
756  typename internal::OutputType<dim, spacedim, Number, Extractor>::
757  third_derivative_type> &
758  get_third_derivatives(const std::string &global_vector_name,
759  const Extractor & variable,
760  const Number dummy = Number(0));
761  // CurrentCellEvaluation
763 
767  const Mapping<dim, spacedim> &
768  get_mapping() const;
769 
770  private:
775  template <typename Extractor, typename Number = double>
776  std::string
777  get_unique_name(const std::string &global_vector_name,
778  const Extractor & variable,
779  const std::string &object_type,
780  const unsigned int size,
781  const Number & exemplar_number) const;
782 
786  template <typename Number = double>
787  std::string
788  get_unique_dofs_name(const std::string &global_vector_name,
789  const unsigned int size,
790  const Number & exemplar_number) const;
791 
797 
803 
809 
815 
820 
825 
831 
837 
841  std::unique_ptr<FEValues<dim, spacedim>> fe_values;
842 
846  std::unique_ptr<FEFaceValues<dim, spacedim>> fe_face_values;
847 
851  std::unique_ptr<FESubfaceValues<dim, spacedim>> fe_subface_values;
852 
856  std::unique_ptr<FEValues<dim, spacedim>> neighbor_fe_values;
857 
861  std::unique_ptr<FEFaceValues<dim, spacedim>> neighbor_fe_face_values;
862 
866  std::unique_ptr<FESubfaceValues<dim, spacedim>> neighbor_fe_subface_values;
867 
871  std::vector<types::global_dof_index> local_dof_indices;
872 
876  std::vector<types::global_dof_index> neighbor_dof_indices;
877 
882 
887 
893 
899  };
900 
901 #ifndef DOXYGEN
902  template <int dim, int spacedim>
903  template <typename Extractor, typename Number>
904  std::string
906  const std::string &global_vector_name,
907  const Extractor & variable,
908  const std::string &object_type,
909  const unsigned int size,
910  const Number & exemplar_number) const
911  {
912  return global_vector_name + "_" + variable.get_name() + "_" + object_type +
913  "_" + Utilities::int_to_string(size) + "_" +
914  Utilities::type_to_string(exemplar_number);
915  }
916 
917 
918 
919  template <int dim, int spacedim>
920  template <typename Number>
921  std::string
923  const std::string &global_vector_name,
924  const unsigned int size,
925  const Number & exemplar_number) const
926  {
927  return global_vector_name + "_independent_local_dofs_" +
928  Utilities::int_to_string(size) + "_" +
929  Utilities::type_to_string(exemplar_number);
930  }
931 
932 
933 
934  template <int dim, int spacedim>
935  template <typename VectorType, typename Number>
936  void
938  const std::string &global_vector_name,
939  const VectorType & input_vector,
940  const Number dummy)
941  {
942  const unsigned int n_dofs = get_current_fe_values().get_fe().dofs_per_cell;
943 
944  const std::string name =
945  get_unique_dofs_name(global_vector_name, n_dofs, dummy);
946 
947  auto &independent_local_dofs =
948  internal_data_storage
949  .template get_or_add_object_with_name<std::vector<Number>>(name,
950  n_dofs);
951 
952  AssertDimension(independent_local_dofs.size(), n_dofs);
953 
955  for (unsigned int i = 0; i < n_dofs; ++i)
957  input_vector(local_dof_indices[i]),
958  i,
959  n_dofs,
960  independent_local_dofs[i]);
961  else
962  for (unsigned int i = 0; i < n_dofs; ++i)
963  independent_local_dofs[i] = input_vector(local_dof_indices[i]);
964  }
965 
966 
967 
968  template <int dim, int spacedim>
969  template <typename Number>
970  const std::vector<Number> &
972  const std::string &global_vector_name,
973  Number dummy) const
974  {
975  const unsigned int n_dofs = get_current_fe_values().get_fe().dofs_per_cell;
976 
977  const std::string dofs_name =
978  get_unique_dofs_name(global_vector_name, n_dofs, dummy);
979 
980  Assert(
981  internal_data_storage.stores_object_with_name(dofs_name),
982  ExcMessage(
983  "You did not call yet extract_local_dof_values with the right types!"));
984 
985  return internal_data_storage
986  .template get_object_with_name<std::vector<Number>>(dofs_name);
987  }
988 
989 
990 
991  template <int dim, int spacedim>
992  template <typename Extractor, typename Number>
993  const std::vector<
994  typename internal::OutputType<dim, spacedim, Number, Extractor>::value_type>
995  &
997  const std::string &global_vector_name,
998  const Extractor & variable,
999  const Number dummy)
1000  {
1001  const std::vector<Number> &independent_local_dofs =
1002  get_local_dof_values(global_vector_name, dummy);
1003 
1004  const FEValuesBase<dim, spacedim> &fev = get_current_fe_values();
1005 
1006  const unsigned int n_q_points = fev.n_quadrature_points;
1007 
1008  const std::string name = get_unique_name(
1009  global_vector_name, variable, "_values_q", n_q_points, dummy);
1010 
1011  // Now build the return type
1012  using RetType =
1013  std::vector<typename internal::
1014  OutputType<dim, spacedim, Number, Extractor>::value_type>;
1015 
1016  RetType &ret =
1017  internal_data_storage.template get_or_add_object_with_name<RetType>(
1018  name, n_q_points);
1019 
1020  AssertDimension(ret.size(), n_q_points);
1021 
1022  fev[variable].get_function_values_from_local_dof_values(
1023  independent_local_dofs, ret);
1024  return ret;
1025  }
1026 
1027 
1028 
1029  template <int dim, int spacedim>
1030  template <typename Extractor, typename Number>
1031  const std::vector<
1032  typename internal::OutputType<dim, spacedim, Number, Extractor>::
1033  gradient_type> &
1035  const std::string &global_vector_name,
1036  const Extractor & variable,
1037  const Number dummy)
1038  {
1039  const std::vector<Number> &independent_local_dofs =
1040  get_local_dof_values(global_vector_name, dummy);
1041 
1042  const FEValuesBase<dim, spacedim> &fev = get_current_fe_values();
1043 
1044  const unsigned int n_q_points = fev.n_quadrature_points;
1045 
1046  const std::string name = get_unique_name(
1047  global_vector_name, variable, "_gradients_q", n_q_points, dummy);
1048 
1049  // Now build the return type
1050  using RetType = std::vector<
1051  typename internal::OutputType<dim, spacedim, Number, Extractor>::
1052  gradient_type>;
1053 
1054  RetType &ret =
1055  internal_data_storage.template get_or_add_object_with_name<RetType>(
1056  name, n_q_points);
1057 
1058  AssertDimension(ret.size(), n_q_points);
1059 
1060  fev[variable].get_function_gradients_from_local_dof_values(
1061  independent_local_dofs, ret);
1062  return ret;
1063  }
1064 
1065 
1066 
1067  template <int dim, int spacedim>
1068  template <typename Extractor, typename Number>
1069  const std::vector<
1070  typename internal::OutputType<dim, spacedim, Number, Extractor>::
1071  hessian_type> &
1073  const std::string &global_vector_name,
1074  const Extractor & variable,
1075  const Number dummy)
1076  {
1077  const std::vector<Number> &independent_local_dofs =
1078  get_local_dof_values(global_vector_name, dummy);
1079 
1080  const FEValuesBase<dim, spacedim> &fev = get_current_fe_values();
1081 
1082  const unsigned int n_q_points = fev.n_quadrature_points;
1083 
1084  const std::string name = get_unique_name(
1085  global_vector_name, variable, "_hessians_q", n_q_points, dummy);
1086 
1087  // Now build the return type
1088  using RetType =
1089  std::vector<typename internal::
1090  OutputType<dim, spacedim, Number, Extractor>::hessian_type>;
1091 
1092  RetType &ret =
1093  internal_data_storage.template get_or_add_object_with_name<RetType>(
1094  name, n_q_points);
1095 
1096 
1097  AssertDimension(ret.size(), n_q_points);
1098 
1099  fev[variable].get_function_hessians_from_local_dof_values(
1100  independent_local_dofs, ret);
1101  return ret;
1102  }
1103 
1104 
1105 
1106  template <int dim, int spacedim>
1107  template <typename Extractor, typename Number>
1108  const std::vector<
1109  typename internal::OutputType<dim, spacedim, Number, Extractor>::
1110  third_derivative_type> &
1112  const std::string &global_vector_name,
1113  const Extractor & variable,
1114  const Number dummy)
1115  {
1116  const std::vector<Number> &independent_local_dofs =
1117  get_local_dof_values(global_vector_name, dummy);
1118 
1119  const FEValuesBase<dim, spacedim> &fev = get_current_fe_values();
1120 
1121  const unsigned int n_q_points = fev.n_quadrature_points;
1122 
1123  const std::string name = get_unique_name(
1124  global_vector_name, variable, "_third_derivatives_q", n_q_points, dummy);
1125 
1126  // Now build the return type
1127  using RetType = std::vector<
1128  typename internal::OutputType<dim, spacedim, Number, Extractor>::
1129  third_derivative_type>;
1130 
1131  RetType &ret =
1132  internal_data_storage.template get_or_add_object_with_name<RetType>(
1133  name, n_q_points);
1134 
1135 
1136  AssertDimension(ret.size(), n_q_points);
1137 
1138  fev[variable].get_function_third_derivatives_from_local_dof_values(
1139  independent_local_dofs, ret);
1140  return ret;
1141  }
1142 
1143 
1144 
1145  template <int dim, int spacedim>
1146  template <typename Extractor, typename Number>
1147  const std::vector<
1148  typename internal::OutputType<dim, spacedim, Number, Extractor>::
1149  symmetric_gradient_type> &
1151  const std::string &global_vector_name,
1152  const Extractor & variable,
1153  const Number dummy)
1154  {
1155  const std::vector<Number> &independent_local_dofs =
1156  get_local_dof_values(global_vector_name, dummy);
1157 
1158  const FEValuesBase<dim, spacedim> &fev = get_current_fe_values();
1159 
1160  const unsigned int n_q_points = fev.n_quadrature_points;
1161 
1162  const std::string name = get_unique_name(
1163  global_vector_name, variable, "_symmetric_gradient_q", n_q_points, dummy);
1164 
1165 
1166  // Now build the return type
1167  using RetType = std::vector<
1168  typename internal::OutputType<dim, spacedim, Number, Extractor>::
1169  symmetric_gradient_type>;
1170 
1171  RetType &ret =
1172  internal_data_storage.template get_or_add_object_with_name<RetType>(
1173  name, n_q_points);
1174 
1175 
1176  AssertDimension(ret.size(), n_q_points);
1177 
1178  fev[variable].get_function_symmetric_gradients_from_local_dof_values(
1179  independent_local_dofs, ret);
1180  return ret;
1181  }
1182 
1183 
1184  template <int dim, int spacedim>
1185  template <typename Extractor, typename Number>
1186  const std::vector<
1187  typename internal::OutputType<dim, spacedim, Number, Extractor>::
1188  divergence_type> &
1190  const std::string &global_vector_name,
1191  const Extractor & variable,
1192  const Number dummy)
1193  {
1194  const std::vector<Number> &independent_local_dofs =
1195  get_local_dof_values(global_vector_name, dummy);
1196 
1197  const FEValuesBase<dim, spacedim> &fev = get_current_fe_values();
1198 
1199  const unsigned int n_q_points = fev.n_quadrature_points;
1200 
1201  const std::string name = get_unique_name(
1202  global_vector_name, variable, "_divergence_q", n_q_points, dummy);
1203 
1204  // Now build the return type
1205  using RetType = std::vector<
1206  typename internal::OutputType<dim, spacedim, Number, Extractor>::
1207  divergence_type>;
1208 
1209  RetType &ret =
1210  internal_data_storage.template get_or_add_object_with_name<RetType>(
1211  name, n_q_points);
1212 
1213 
1214  AssertDimension(ret.size(), n_q_points);
1215 
1216  fev[variable].get_function_divergences_from_local_dof_values(
1217  independent_local_dofs, ret);
1218  return ret;
1219  }
1220 
1221 
1222 
1223  template <int dim, int spacedim>
1224  template <typename Extractor, typename Number>
1225  const std::vector<
1226  typename internal::OutputType<dim, spacedim, Number, Extractor>::curl_type>
1227  &
1228  ScratchData<dim, spacedim>::get_curls(const std::string &global_vector_name,
1229  const Extractor & variable,
1230  const Number dummy)
1231  {
1232  const std::vector<Number> &independent_local_dofs =
1233  get_local_dof_values(global_vector_name, dummy);
1234 
1235  const FEValuesBase<dim, spacedim> &fev = get_current_fe_values();
1236 
1237  const unsigned int n_q_points = fev.n_quadrature_points;
1238 
1239  const std::string name = get_unique_name(
1240  global_vector_name, variable, "_curl_q", n_q_points, dummy);
1241 
1242  // Now build the return type
1243  using RetType =
1244  std::vector<typename internal::
1245  OutputType<dim, spacedim, Number, Extractor>::curl_type>;
1246 
1247  RetType &ret =
1248  internal_data_storage.template get_or_add_object_with_name<RetType>(
1249  name, n_q_points);
1250 
1251  AssertDimension(ret.size(), n_q_points);
1252 
1253  fev[variable].get_function_curls_from_local_dof_values(
1254  independent_local_dofs, ret);
1255  return ret;
1256  }
1257 
1258 #endif
1259 
1260 } // namespace MeshWorker
1261 
1262 DEAL_II_NAMESPACE_CLOSE
1263 
1264 #endif
GeneralDataStorage internal_data_storage
Definition: scratch_data.h:886
SmartPointer< FEValuesBase< dim, spacedim > > current_fe_values
Definition: scratch_data.h:892
std::string type_to_string(const T &t)
Definition: utilities.h:1058
#define AssertDimension(dim1, dim2)
Definition: exceptions.h:1567
std::unique_ptr< FEFaceValues< dim, spacedim > > fe_face_values
Definition: scratch_data.h:846
const std::vector< typename internal::OutputType< dim, spacedim, Number, Extractor >::gradient_type > & get_gradients(const std::string &global_vector_name, const Extractor &variable, const Number dummy=Number(0))
Quadrature< dim > cell_quadrature
Definition: scratch_data.h:808
SmartPointer< const Mapping< dim, spacedim > > mapping
Definition: scratch_data.h:796
const Mapping< dim, spacedim > & get_mapping() const
std::string get_unique_dofs_name(const std::string &global_vector_name, const unsigned int size, const Number &exemplar_number) const
std::unique_ptr< FEValues< dim, spacedim > > neighbor_fe_values
Definition: scratch_data.h:856
UpdateFlags neighbor_face_update_flags
Definition: scratch_data.h:836
const std::vector< typename internal::OutputType< dim, spacedim, Number, Extractor >::value_type > & get_values(const std::string &global_vector_name, const Extractor &variable, const Number dummy=Number(0))
const std::vector< types::global_dof_index > & get_local_dof_indices() const
const FEValuesBase< dim, spacedim > & get_current_neighbor_fe_values() const
const std::vector< typename internal::OutputType< dim, spacedim, Number, Extractor >::symmetric_gradient_type > & get_symmetric_gradients(const std::string &global_vector_name, const Extractor &variable, const Number dummy=Number(0))
const FEValues< dim, spacedim > & reinit(const typename DoFHandler< dim, spacedim >::active_cell_iterator &cell)
UpdateFlags neighbor_cell_update_flags
Definition: scratch_data.h:824
const std::vector< Tensor< 1, spacedim > > & get_neighbor_normal_vectors()
std::vector< types::global_dof_index > neighbor_dof_indices
Definition: scratch_data.h:876
ScratchData(const Mapping< dim, spacedim > &mapping, const FiniteElement< dim, spacedim > &fe, const Quadrature< dim > &quadrature, const UpdateFlags &update_flags, const Quadrature< dim - 1 > &face_quadrature=Quadrature< dim - 1 >(), const UpdateFlags &face_update_flags=update_default)
Definition: scratch_data.cc:23
GeneralDataStorage & get_general_data_storage()
const std::vector< typename internal::OutputType< dim, spacedim, Number, Extractor >::hessian_type > & get_hessians(const std::string &global_vector_name, const Extractor &variable, const Number dummy=Number(0))
typename internal::FEValuesViews::ViewType< dim, spacedim, Extractor >::type View
Definition: fe_values.h:1976
std::unique_ptr< FESubfaceValues< dim, spacedim > > fe_subface_values
Definition: scratch_data.h:851
std::unique_ptr< FESubfaceValues< dim, spacedim > > neighbor_fe_subface_values
Definition: scratch_data.h:866
static ::ExceptionBase & ExcMessage(std::string arg1)
No update.
const FEValues< dim, spacedim > & reinit_neighbor(const typename DoFHandler< dim, spacedim >::active_cell_iterator &cell)
#define Assert(cond, exc)
Definition: exceptions.h:1407
UpdateFlags
const std::vector< Tensor< 1, spacedim > > & get_normal_vectors() const
Abstract base class for mapping classes.
Definition: dof_tools.h:57
const std::vector< Point< spacedim > > & get_quadrature_points() const
SmartPointer< FEValuesBase< dim, spacedim > > current_neighbor_fe_values
Definition: scratch_data.h:898
std::unique_ptr< FEFaceValues< dim, spacedim > > neighbor_fe_face_values
Definition: scratch_data.h:861
UpdateFlags face_update_flags
Definition: scratch_data.h:830
GeneralDataStorage user_data_storage
Definition: scratch_data.h:881
std::string get_unique_name(const std::string &global_vector_name, const Extractor &variable, const std::string &object_type, const unsigned int size, const Number &exemplar_number) const
const std::vector< typename internal::OutputType< dim, spacedim, Number, Extractor >::third_derivative_type > & get_third_derivatives(const std::string &global_vector_name, const Extractor &variable, const Number dummy=Number(0))
const std::vector< typename internal::OutputType< dim, spacedim, Number, Extractor >::curl_type > & get_curls(const std::string &global_vector_name, const Extractor &variable, const Number dummy=Number(0))
std::string int_to_string(const unsigned int value, const unsigned int digits=numbers::invalid_unsigned_int)
Definition: utilities.cc:383
void extract_local_dof_values(const std::string &global_vector_name, const VectorType &input_vector, const Number dummy=Number(0))
UpdateFlags cell_update_flags
Definition: scratch_data.h:819
const unsigned int n_quadrature_points
Definition: fe_values.h:2099
Quadrature< dim - 1 > face_quadrature
Definition: scratch_data.h:814
std::unique_ptr< FEValues< dim, spacedim > > fe_values
Definition: scratch_data.h:841
const std::vector< types::global_dof_index > & get_neighbor_dof_indices() const
const std::vector< typename internal::OutputType< dim, spacedim, Number, Extractor >::divergence_type > & get_divergences(const std::string &global_vector_name, const Extractor &variable, const Number dummy=Number(0))
const FEValuesBase< dim, spacedim > & get_current_fe_values() const
Definition: fe.h:38
const std::vector< double > & get_neighbor_JxW_values() const
const std::vector< double > & get_JxW_values() const
typename ActiveSelector::active_cell_iterator active_cell_iterator
Definition: dof_handler.h:324
std::vector< types::global_dof_index > local_dof_indices
Definition: scratch_data.h:871
SmartPointer< const FiniteElement< dim, spacedim > > fe
Definition: scratch_data.h:802
const std::vector< Number > & get_local_dof_values(const std::string &global_vector_name, Number dummy=Number(0)) const