From: janssen Date: Sat, 26 May 2012 22:26:25 +0000 (+0000) Subject: check new update_flags for higher derivatives and andd new functions and X-Git-Url: https://gitweb.dealii.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=980d3f4c34f0c60d8abf378b8cad277c3aa313cc;p=dealii-svn.git check new update_flags for higher derivatives and andd new functions and variables for higher derivatives git-svn-id: https://svn.dealii.org/branches/branch_higher_derivatives@25548 0785d39b-7218-0410-832d-ea1e28bc413d --- diff --git a/deal.II/include/deal.II/base/polynomial_space.h b/deal.II/include/deal.II/base/polynomial_space.h index 1caa9e997a..a67996ca29 100644 --- a/deal.II/include/deal.II/base/polynomial_space.h +++ b/deal.II/include/deal.II/base/polynomial_space.h @@ -21,6 +21,7 @@ #include #include +#include DEAL_II_NAMESPACE_OPEN @@ -186,6 +187,10 @@ class PolynomialSpace Tensor<2,dim> compute_hessian (const unsigned int i, const Point &p) const; + boost::any compute_nth_derivative (const unsigned int i, + const Point &p, + const unsigned int nth_derivative) const; + /** * Return the number of * polynomials spanning the space diff --git a/deal.II/include/deal.II/base/tensor_product_polynomials.h b/deal.II/include/deal.II/base/tensor_product_polynomials.h index 8108852dc9..73c5f21eed 100644 --- a/deal.II/include/deal.II/base/tensor_product_polynomials.h +++ b/deal.II/include/deal.II/base/tensor_product_polynomials.h @@ -20,6 +20,7 @@ #include #include +#include DEAL_II_NAMESPACE_OPEN @@ -218,6 +219,10 @@ class TensorProductPolynomials Tensor<2,dim> compute_hessian (const unsigned int i, const Point &p) const; + boost::any compute_nth_derivative (const unsigned int i, + const Point &, + const unsigned int nth_derivative) const; + /** * Returns the number of tensor * product polynomials. For n @@ -450,6 +455,9 @@ class AnisotropicPolynomials Tensor<2,dim> compute_hessian (const unsigned int i, const Point &p) const; + template + Tensor compute_nth_derivatives (const unsigned int i, + const Point &) const; /** * Returns the number of tensor * product polynomials. It is the diff --git a/deal.II/include/deal.II/fe/fe.h b/deal.II/include/deal.II/fe/fe.h index cd32d2eca1..b2eb49ffce 100644 --- a/deal.II/include/deal.II/fe/fe.h +++ b/deal.II/include/deal.II/fe/fe.h @@ -628,11 +628,12 @@ class FiniteElement : public Subscriptor, const unsigned int component) const; /** - * - * @param i + * For computing the + * @param nth_derivative derivatives of the + * @param i th shape_function at point * @param p - * @param nth_derivative - * @return ...say that the any-type can only store Tensor + * @param nth_derivative. The return value + * @return can only store Tensor. */ virtual boost::any @@ -640,6 +641,15 @@ class FiniteElement : public Subscriptor, const Point &p, const unsigned int nth_derivative) const; + /** + * For computing the + * @param nth_derivative derivatives of the + * @param i th shape_function in the + * @param component component at point + * @param p + * @param nth_derivative. The return value + * @return can only store Tensor. + */ virtual boost::any shape_nth_derivative_component (const unsigned int i, diff --git a/deal.II/include/deal.II/fe/fe_poly.h b/deal.II/include/deal.II/fe/fe_poly.h index ca0da2666e..2f95eaa759 100644 --- a/deal.II/include/deal.II/fe/fe_poly.h +++ b/deal.II/include/deal.II/fe/fe_poly.h @@ -39,6 +39,10 @@ DEAL_II_NAMESPACE_OPEN * * Tensor<2,dim> compute_hessian (const unsigned int i, * const Point &p) const; + * + * boost::any compute_nth_derivative (const unsigned int i, + * const Point &p, + * const unsigned int nth_derivative) const; * @endcode * Example classes are TensorProductPolynomials, PolynomialSpace or * PolynomialsP. @@ -194,6 +198,50 @@ class FE_Poly : public FiniteElement virtual Tensor<2,dim> shape_hessian_component (const unsigned int i, const Point &p, const unsigned int component) const; + + /** + * Return the tensor of the + * @param nth_derivative th + * derivatives of the + * @param i th shape function at + * point + * @param p on the unit + * cell. See the + * FiniteElement base class + * for more information about the + * semantics of this function. + */ + virtual + boost::any + shape_nth_derivative (const unsigned int i, + const Point &p, + const unsigned int nth_derivative) const; + + /** + * Return the tensor of the + * @param nth_derivative th + * derivatives of the + * @param i th shape function at + * point + * @param p on the unit + * cell. See the + * FiniteElement base class + * for more information about the + * semantics of this function. + * + * Since this element is scalar, + * the returned value is the same + * as if the function without the + * @param component suffix + * were called, provided that the + * specified component is zero. + */ + virtual + boost::any + shape_nth_derivative_component (const unsigned int i, + const Point &p, + const unsigned int component, + const unsigned int nth_derivative) const; protected: virtual @@ -368,6 +416,14 @@ class FE_Poly : public FiniteElement * visiting an actual cell. */ std::vector > > shape_gradients; + std::vector > > shape_hessians; + std::vector > > shape_3rd_derivatives; + std::vector > > shape_4th_derivatives; + std::vector > > shape_5th_derivatives; + std::vector > > shape_6th_derivatives; + std::vector > > shape_7th_derivatives; + std::vector > > shape_8th_derivatives; + std::vector > > shape_9th_derivatives; }; /** diff --git a/deal.II/include/deal.II/fe/fe_poly.templates.h b/deal.II/include/deal.II/fe/fe_poly.templates.h index 4fe053bdf9..5385211949 100644 --- a/deal.II/include/deal.II/fe/fe_poly.templates.h +++ b/deal.II/include/deal.II/fe/fe_poly.templates.h @@ -112,6 +112,31 @@ FE_Poly::shape_hessian_component (const unsigned int i, +template +boost::any +FE_Poly::shape_nth_derivative (const unsigned int i, + const Point &p, + const unsigned int nth_derivative) const +{ + Assert (idofs_per_cell, ExcIndexRange(i,0,this->dofs_per_cell)); + return poly_space.compute_nth_derivative(i, p, nth_derivative); +} + + + +template +boost::any +FE_Poly::shape_nth_derivative_component (const unsigned int i, + const Point &p, + const unsigned int component, + const unsigned int nth_derivative) const +{ + Assert (idofs_per_cell, ExcIndexRange(i,0,this->dofs_per_cell)); + Assert (component == 0, ExcIndexRange (component, 0, 1)); + return poly_space.compute_nth_derivative(i, p, nth_derivative); +} + + //--------------------------------------------------------------------------- // Auxiliary functions //--------------------------------------------------------------------------- @@ -143,6 +168,20 @@ FE_Poly::update_each (const UpdateFlags flags) const out |= update_gradients | update_covariant_transformation; if (flags & update_hessians) out |= update_hessians | update_covariant_transformation; + if (flags & update_3rd_derivatives) + out |= update_3rd_derivatives | update_covariant_transformation; + if (flags & update_4th_derivatives) + out |= update_4th_derivatives | update_covariant_transformation; + if (flags & update_5th_derivatives) + out |= update_5th_derivatives | update_covariant_transformation; + if (flags & update_6th_derivatives) + out |= update_6th_derivatives | update_covariant_transformation; + if (flags & update_7th_derivatives) + out |= update_7th_derivatives | update_covariant_transformation; + if (flags & update_8th_derivatives) + out |= update_8th_derivatives | update_covariant_transformation; + if (flags & update_9th_derivatives) + out |= update_9th_derivatives | update_covariant_transformation; if (flags & update_cell_normal_vectors) out |= update_cell_normal_vectors | update_JxW_values; @@ -180,30 +219,86 @@ FE_Poly::get_data (const UpdateFlags update_flags, std::vector values(0); std::vector > grads(0); std::vector > hessians(0); + std::vector > third_derivatives(0); + std::vector > fourth_derivatives(0); + std::vector > fifth_derivatives(0); + std::vector > sixth_derivatives(0); + std::vector > seventh_derivatives(0); + std::vector > eighth_derivatives(0); + std::vector > ninth_derivatives(0); // initialize fields only if really // necessary. otherwise, don't // allocate memory if (flags & update_values) - { - values.resize (this->dofs_per_cell); - data->shape_values.resize (this->dofs_per_cell, - std::vector (n_q_points)); - } + { + values.resize (this->dofs_per_cell); + data->shape_values.resize (this->dofs_per_cell, + std::vector (n_q_points)); + } if (flags & update_gradients) - { - grads.resize (this->dofs_per_cell); - data->shape_gradients.resize (this->dofs_per_cell, - std::vector > (n_q_points)); - } + { + grads.resize (this->dofs_per_cell); + data->shape_gradients.resize (this->dofs_per_cell, + std::vector > (n_q_points)); + } - // if second derivatives through - // finite differencing is required, - // then initialize some objects for - // that if (flags & update_hessians) - data->initialize_2nd (this, mapping, quadrature); + { + hessians.resize (this->dofs_per_cell); + data->shape_hessians.resize (this->dofs_per_cell, + std::vector >(n_q_points)); + } + + if (flags & update_3rd_derivatives) + { + third_derivatives.resize (this->dofs_per_cell); + data->shape_3rd_derivatives.resize (this->dofs_per_cell, + std::vector >(n_q_points)); + } + + if (flags & update_4th_derivatives) + { + fourth_derivatives.resize (this->dofs_per_cell); + data->shape_4th_derivatives.resize (this->dofs_per_cell, + std::vector >(n_q_points)); + } + + if (flags & update_5th_derivatives) + { + fifth_derivatives.resize (this->dofs_per_cell); + data->shape_5th_derivatives.resize (this->dofs_per_cell, + std::vector >(n_q_points)); + } + + if (flags & update_6th_derivatives) + { + sixth_derivatives.resize (this->dofs_per_cell); + data->shape_6th_derivatives.resize (this->dofs_per_cell, + std::vector >(n_q_points)); + } + + if (flags & update_7th_derivatives) + { + seventh_derivatives.resize (this->dofs_per_cell); + data->shape_7th_derivatives.resize (this->dofs_per_cell, + std::vector >(n_q_points)); + } + + if (flags & update_8th_derivatives) + { + eighth_derivatives.resize (this->dofs_per_cell); + data->shape_8th_derivatives.resize (this->dofs_per_cell, + std::vector >(n_q_points)); + } + + if (flags & update_9th_derivatives) + { + ninth_derivatives.resize (this->dofs_per_cell); + data->shape_9th_derivatives.resize (this->dofs_per_cell, + std::vector >(n_q_points)); + } // next already fill those fields // of which we have information by @@ -212,6 +307,7 @@ FE_Poly::get_data (const UpdateFlags update_flags, // unit cell, and need to be // transformed when visiting an // actual cell + //TODO[BJ] add higher derivatives here if (flags & (update_values | update_gradients)) for (unsigned int i=0; i virtual Tensor<2,dim> shape_hessian_component (const unsigned int i, const Point &p, const unsigned int component) const; + + /** + * Since these elements are + * vector valued, an exception is + * thrown. + */ + virtual boost::any shape_nth_derivative (const unsigned int i, + const Point &p, + const unsigned int nth_derivative) const; + + virtual boost::any shape_nth_derivative_component (const unsigned int i, + const Point &p, + const unsigned int component, + const unsigned int nth_derivative) const; /** * Given flags, @@ -332,6 +346,16 @@ class FE_PolyTensor : public FiniteElement * shape_hessian_component(). */ mutable std::vector > cached_hessians; + + mutable std::vector > cached_nth_derivatives; + + mutable std::vector > cached_3rd_derivatives; + mutable std::vector > cached_4th_derivatives; + mutable std::vector > cached_5th_derivatives; + mutable std::vector > cached_6th_derivatives; + mutable std::vector > cached_7th_derivatives; + mutable std::vector > cached_8th_derivatives; + mutable std::vector > cached_9th_derivatives; }; DEAL_II_NAMESPACE_CLOSE diff --git a/deal.II/include/deal.II/fe/fe_update_flags.h b/deal.II/include/deal.II/fe/fe_update_flags.h index f20c662cf2..cc7bcb26b3 100644 --- a/deal.II/include/deal.II/fe/fe_update_flags.h +++ b/deal.II/include/deal.II/fe/fe_update_flags.h @@ -322,7 +322,37 @@ enum UpdateFlags update_piola = update_volume_elements | update_contravariant_transformation }; -UpdateFlags update_nth_derivatives (const unsigned int nth_derivative); +inline +UpdateFlags update_nth_derivatives (const unsigned int nth_derivative) +{ + switch (nth_derivative) + { + case 0: + return update_values; + case 1: + return update_gradients; + case 2: + return update_hessians; + case 3: + return update_3rd_derivatives; + case 4: + return update_4th_derivatives; + case 5: + return update_5th_derivatives; + case 6: + return update_6th_derivatives; + case 7: + return update_7th_derivatives; + case 8: + return update_8th_derivatives; + case 9: + return update_9th_derivatives; + default: + Assert (nth_derivative<10, ExcNotImplemented()); + } + return UpdateFlags(); +} + /** @@ -338,6 +368,13 @@ STREAM& operator << (STREAM& s, UpdateFlags u) if (u & update_values) s << "values|"; if (u & update_gradients) s << "gradients|"; if (u & update_hessians) s << "hessians|"; + if (u & update_3rd_derivatives) s << "3rd_derivatives|"; + if (u & update_4th_derivatives) s << "4th_derivatives|"; + if (u & update_5th_derivatives) s << "5th_derivatives|"; + if (u & update_6th_derivatives) s << "6th_derivatives|"; + if (u & update_7th_derivatives) s << "7th_derivatives|"; + if (u & update_8th_derivatives) s << "8th_derivatives|"; + if (u & update_9th_derivatives) s << "9th_derivatives|"; if (u & update_quadrature_points) s << "quadrature_points|"; if (u & update_JxW_values) s << "JxW_values|"; if (u & update_normal_vectors) s << "normal_vectors|"; @@ -426,6 +463,111 @@ operator &= (UpdateFlags &f1, UpdateFlags f2) return f1; } +inline +UpdateFlags update_up_to_nth_derivatives (const unsigned int nth_derivative) +{ + UpdateFlags return_flags; + return_flags = update_values; + if(nth_derivative<1) + return return_flags; + + return_flags |= update_gradients; + if(nth_derivative<2) + return return_flags; + + return_flags |= update_hessians; + if(nth_derivative<3) + return return_flags; + + return_flags |= update_3rd_derivatives; + if(nth_derivative<4) + return return_flags; + + return_flags |= update_4th_derivatives; + if(nth_derivative<5) + return return_flags; + + return_flags |= update_5th_derivatives; + if(nth_derivative<6) + return return_flags; + + return_flags |= update_6th_derivatives; + if(nth_derivative<7) + return return_flags; + + return_flags |= update_7th_derivatives; + if(nth_derivative<8) + return return_flags; + + return_flags |= update_8th_derivatives; + if(nth_derivative<9) + return return_flags; + + return_flags |= update_9th_derivatives; + if(nth_derivative<10) + return return_flags; + + Assert (nth_derivative<10, ExcNotImplemented()); + return UpdateFlags(); +} + + + +inline +UpdateFlags update_derivatives (const unsigned int nth_derivative, const unsigned int mth_derivative) +{ + UpdateFlags return_flags = update_nth_derivatives(nth_derivative); + if(mth_derivative<1) + return return_flags; + + if(nth_derivative<1) + return_flags |= update_gradients; + if(mth_derivative<2) + return return_flags; + + if(nth_derivative<2) + return_flags |= update_hessians; + if(mth_derivative<3) + return return_flags; + + if(nth_derivative<3) + return_flags |= update_3rd_derivatives; + if(mth_derivative<4) + return return_flags; + + if(nth_derivative<4) + return_flags |= update_4th_derivatives; + if(mth_derivative<5) + return return_flags; + + if(nth_derivative<5) + return_flags |= update_5th_derivatives; + if(mth_derivative<6) + return return_flags; + + if(nth_derivative<6) + return_flags |= update_6th_derivatives; + if(mth_derivative<7) + return return_flags; + + if(nth_derivative<7) + return_flags |= update_7th_derivatives; + if(mth_derivative<8) + return return_flags; + + if(nth_derivative<8) + return_flags |= update_8th_derivatives; + if(mth_derivative<9) + return return_flags; + + if(nth_derivative<9) + return_flags |= update_9th_derivatives; + if(mth_derivative<10) + return return_flags; + + Assert (mth_derivative<10, ExcNotImplemented()); + return UpdateFlags(); +} /** diff --git a/deal.II/source/base/polynomial_space.cc b/deal.II/source/base/polynomial_space.cc index 1199671b9a..df7dda0307 100644 --- a/deal.II/source/base/polynomial_space.cc +++ b/deal.II/source/base/polynomial_space.cc @@ -203,6 +203,46 @@ PolynomialSpace::compute_hessian (const unsigned int i, +template +boost::any +PolynomialSpace::compute_nth_derivative (const unsigned int i, + const Point &p, + const unsigned int nth_derivative) const +{ + /* + unsigned int ix[dim]; + compute_index(i,ix); + + Tensor<2,dim> result; + for (unsigned int d=0; d v(3); + for (unsigned int d=0; d void diff --git a/deal.II/source/base/tensor_product_polynomials.cc b/deal.II/source/base/tensor_product_polynomials.cc index 62d0c3d723..7b052f0f67 100644 --- a/deal.II/source/base/tensor_product_polynomials.cc +++ b/deal.II/source/base/tensor_product_polynomials.cc @@ -206,6 +206,52 @@ TensorProductPolynomials::compute_hessian (const unsigned int i, return hessian; } +template +boost::any +TensorProductPolynomials::compute_nth_derivative (const unsigned int i, + const Point &p, + const unsigned int nth_derivative) const +{ + /* + unsigned int indices[dim]; + compute_index (i, indices); + + double v [dim][3]; + { + std::vector tmp (3); + for (unsigned int d=0; d hessian; + for (unsigned int d1=0; d1::shape_hessian_component (const unsigned int i, } +template +boost::any +FE_PolyTensor::shape_nth_derivative (const unsigned int, const Point &, const unsigned int) const +{ + typedef FiniteElement FEE; + Assert(false, typename FEE::ExcFENotPrimitive()); + return Tensor<2,dim>(); +} + + + +template +boost::any +FE_PolyTensor::shape_nth_derivative_component (const unsigned int i, + const Point &p, + const unsigned int component, + const unsigned int nth_derivative) const +{ + Assert (idofs_per_cell, ExcIndexRange(i,0,this->dofs_per_cell)); + Assert (component < dim, ExcIndexRange (component, 0, dim)); + + if (cached_point != p || cached_nth_derivatives[nth_derivative].size() == 0) + { + cached_point = p; + cached_nth_derivatives[nth_derivative].resize(poly_space.n()); + //poly_space.compute(p, cached_values, cached_grads, cached_hessians); + } + + boost::any s; + /* + if (inverse_node_matrix.n_cols() == 0) + return cached_nth_derivatives[nth_derivative][i][component]; + else + for (unsigned int j=0;j +#include + +#include +#include + +#define PRECISION 5 + +void test () +{ + //Note that derivatives are implemented up to order 9 only + for (unsigned int d=0; d<10; ++d) + deallog.get_file_stream() << update_nth_derivatives(d) << std::endl; + + deallog << std::endl; + for (unsigned int d=0; d<10; ++d) + deallog.get_file_stream() << update_up_to_nth_derivatives(d) << std::endl; + + deallog << std::endl; + for (unsigned int d=0; d<10; ++d) + for (unsigned int c=d; c<10; ++c) + deallog.get_file_stream() << update_derivatives(d,c) << std::endl; +} + + +int +main() +{ + std::ofstream logfile ("update_flags_higher_derivatives/output"); + deallog << std::setprecision(PRECISION); + deallog << std::fixed; + deallog.attach(logfile); + deallog.depth_console(0); + deallog.threshold_double(1.e-10); + + test (); + + return 0; +} + + + diff --git a/tests/fe/update_flags_higher_derivatives/cmp/generic b/tests/fe/update_flags_higher_derivatives/cmp/generic new file mode 100644 index 0000000000..4f6ddfa343 --- /dev/null +++ b/tests/fe/update_flags_higher_derivatives/cmp/generic @@ -0,0 +1,78 @@ + + UpdateFlags|values| + UpdateFlags|gradients| + UpdateFlags|hessians| + UpdateFlags|3rd_derivatives| + UpdateFlags|4th_derivatives| + UpdateFlags|5th_derivatives| + UpdateFlags|6th_derivatives| + UpdateFlags|7th_derivatives| + UpdateFlags|8th_derivatives| + UpdateFlags|9th_derivatives| +DEAL:: + UpdateFlags|values| + UpdateFlags|values|gradients| + UpdateFlags|values|gradients|hessians| + UpdateFlags|values|gradients|hessians|3rd_derivatives| + UpdateFlags|values|gradients|hessians|3rd_derivatives|4th_derivatives| + UpdateFlags|values|gradients|hessians|3rd_derivatives|4th_derivatives|5th_derivatives| + UpdateFlags|values|gradients|hessians|3rd_derivatives|4th_derivatives|5th_derivatives|6th_derivatives| + UpdateFlags|values|gradients|hessians|3rd_derivatives|4th_derivatives|5th_derivatives|6th_derivatives|7th_derivatives| + UpdateFlags|values|gradients|hessians|3rd_derivatives|4th_derivatives|5th_derivatives|6th_derivatives|7th_derivatives|8th_derivatives| + UpdateFlags|values|gradients|hessians|3rd_derivatives|4th_derivatives|5th_derivatives|6th_derivatives|7th_derivatives|8th_derivatives|9th_derivatives| +DEAL:: + UpdateFlags|values| + UpdateFlags|values|gradients| + UpdateFlags|values|gradients|hessians| + UpdateFlags|values|gradients|hessians|3rd_derivatives| + UpdateFlags|values|gradients|hessians|3rd_derivatives|4th_derivatives| + UpdateFlags|values|gradients|hessians|3rd_derivatives|4th_derivatives|5th_derivatives| + UpdateFlags|values|gradients|hessians|3rd_derivatives|4th_derivatives|5th_derivatives|6th_derivatives| + UpdateFlags|values|gradients|hessians|3rd_derivatives|4th_derivatives|5th_derivatives|6th_derivatives|7th_derivatives| + UpdateFlags|values|gradients|hessians|3rd_derivatives|4th_derivatives|5th_derivatives|6th_derivatives|7th_derivatives|8th_derivatives| + UpdateFlags|values|gradients|hessians|3rd_derivatives|4th_derivatives|5th_derivatives|6th_derivatives|7th_derivatives|8th_derivatives|9th_derivatives| + UpdateFlags|gradients| + UpdateFlags|gradients|hessians| + UpdateFlags|gradients|hessians|3rd_derivatives| + UpdateFlags|gradients|hessians|3rd_derivatives|4th_derivatives| + UpdateFlags|gradients|hessians|3rd_derivatives|4th_derivatives|5th_derivatives| + UpdateFlags|gradients|hessians|3rd_derivatives|4th_derivatives|5th_derivatives|6th_derivatives| + UpdateFlags|gradients|hessians|3rd_derivatives|4th_derivatives|5th_derivatives|6th_derivatives|7th_derivatives| + UpdateFlags|gradients|hessians|3rd_derivatives|4th_derivatives|5th_derivatives|6th_derivatives|7th_derivatives|8th_derivatives| + UpdateFlags|gradients|hessians|3rd_derivatives|4th_derivatives|5th_derivatives|6th_derivatives|7th_derivatives|8th_derivatives|9th_derivatives| + UpdateFlags|hessians| + UpdateFlags|hessians|3rd_derivatives| + UpdateFlags|hessians|3rd_derivatives|4th_derivatives| + UpdateFlags|hessians|3rd_derivatives|4th_derivatives|5th_derivatives| + UpdateFlags|hessians|3rd_derivatives|4th_derivatives|5th_derivatives|6th_derivatives| + UpdateFlags|hessians|3rd_derivatives|4th_derivatives|5th_derivatives|6th_derivatives|7th_derivatives| + UpdateFlags|hessians|3rd_derivatives|4th_derivatives|5th_derivatives|6th_derivatives|7th_derivatives|8th_derivatives| + UpdateFlags|hessians|3rd_derivatives|4th_derivatives|5th_derivatives|6th_derivatives|7th_derivatives|8th_derivatives|9th_derivatives| + UpdateFlags|3rd_derivatives| + UpdateFlags|3rd_derivatives|4th_derivatives| + UpdateFlags|3rd_derivatives|4th_derivatives|5th_derivatives| + UpdateFlags|3rd_derivatives|4th_derivatives|5th_derivatives|6th_derivatives| + UpdateFlags|3rd_derivatives|4th_derivatives|5th_derivatives|6th_derivatives|7th_derivatives| + UpdateFlags|3rd_derivatives|4th_derivatives|5th_derivatives|6th_derivatives|7th_derivatives|8th_derivatives| + UpdateFlags|3rd_derivatives|4th_derivatives|5th_derivatives|6th_derivatives|7th_derivatives|8th_derivatives|9th_derivatives| + UpdateFlags|4th_derivatives| + UpdateFlags|4th_derivatives|5th_derivatives| + UpdateFlags|4th_derivatives|5th_derivatives|6th_derivatives| + UpdateFlags|4th_derivatives|5th_derivatives|6th_derivatives|7th_derivatives| + UpdateFlags|4th_derivatives|5th_derivatives|6th_derivatives|7th_derivatives|8th_derivatives| + UpdateFlags|4th_derivatives|5th_derivatives|6th_derivatives|7th_derivatives|8th_derivatives|9th_derivatives| + UpdateFlags|5th_derivatives| + UpdateFlags|5th_derivatives|6th_derivatives| + UpdateFlags|5th_derivatives|6th_derivatives|7th_derivatives| + UpdateFlags|5th_derivatives|6th_derivatives|7th_derivatives|8th_derivatives| + UpdateFlags|5th_derivatives|6th_derivatives|7th_derivatives|8th_derivatives|9th_derivatives| + UpdateFlags|6th_derivatives| + UpdateFlags|6th_derivatives|7th_derivatives| + UpdateFlags|6th_derivatives|7th_derivatives|8th_derivatives| + UpdateFlags|6th_derivatives|7th_derivatives|8th_derivatives|9th_derivatives| + UpdateFlags|7th_derivatives| + UpdateFlags|7th_derivatives|8th_derivatives| + UpdateFlags|7th_derivatives|8th_derivatives|9th_derivatives| + UpdateFlags|8th_derivatives| + UpdateFlags|8th_derivatives|9th_derivatives| + UpdateFlags|9th_derivatives|