x_fe_values.resize(this->finite_elements.size());
for (unsigned int i = 0; i < this->finite_elements.size(); ++i)
{
- // check if there is a finite element that is equal to the
- // present one, then we can re-use the FEValues object
+ // check if there is a finite element that is equal to the present
+ // one, then we can re-use the FEValues object
for (unsigned int j = 0; j < i; ++j)
if (this->finite_elements[i].get() ==
this->finite_elements[j].get())
x_fe_face_values.resize(this->finite_elements.size());
for (unsigned int i = 0; i < this->finite_elements.size(); ++i)
{
- // check if there is a finite element that is equal to the
- // present one, then we can re-use the FEValues object
+ // check if there is a finite element that is equal to the present
+ // one, then we can re-use the FEValues object
for (unsigned int j = 0; j < i; ++j)
if (this->finite_elements[i].get() ==
this->finite_elements[j].get())
x_fe_values.resize(this->finite_elements.size());
for (unsigned int i = 0; i < this->finite_elements.size(); ++i)
{
- // check if there is a finite element that is equal to the
- // present one, then we can re-use the FEValues object
+ // check if there is a finite element that is equal to the present
+ // one, then we can re-use the FEValues object
for (unsigned int j = 0; j < i; ++j)
if (this->finite_elements[i].get() ==
this->finite_elements[j].get())
x_fe_face_values.resize(this->finite_elements.size());
for (unsigned int i = 0; i < this->finite_elements.size(); ++i)
{
- // check if there is a finite element that is equal to the
- // present one, then we can re-use the FEValues object
+ // check if there is a finite element that is equal to the present
+ // one, then we can re-use the FEValues object
for (unsigned int j = 0; j < i; ++j)
if (this->finite_elements[i].get() ==
this->finite_elements[j].get())
namespace DataOutImplementation
{
/**
- * Extract the specified component of a number. This template is used
- * when the given value is assumed to be a real scalar, so asking
- * for the real part is the only valid choice for the second argument.
+ * Extract the specified component of a number. This template is used when
+ * the given value is assumed to be a real scalar, so asking for the real
+ * part is the only valid choice for the second argument.
*/
template <typename NumberType>
double
/**
- * Extract the specified component of a number. This template is used
- * when the given value is a complex number
+ * Extract the specified component of a number. This template is used when
+ * the given value is a complex number
*/
template <typename NumberType>
double
fe_patch_values.get_function_values(
*vector,
- // reinterpret output argument type; because of
- // the 'if' statement above, this is the
- // identity cast whenever the code is
- // executed, but the cast is necessary
- // to allow compilation even if we don't get here
+ // reinterpret output argument type; because of the 'if' statement
+ // above, this is the identity cast whenever the code is executed,
+ // but the cast is necessary to allow compilation even if we don't
+ // get here
reinterpret_cast<
std::vector<dealii::Vector<typename VectorType::value_type>> &>(
patch_values_system));
else
{
// OK, so we know that the data type stored by the user-provided
- // vector is not simply a double. In that case, we need to
- // ask the FEValuesBase object to extract function values for
- // us from the evaluation points in the provided data
- // type, and then copy them by hand into the output location.
+ // vector is not simply a double. In that case, we need to ask the
+ // FEValuesBase object to extract function values for us from the
+ // evaluation points in the provided data type, and then copy them by
+ // hand into the output location.
const unsigned int n_components =
fe_patch_values.get_fe().n_components();
const unsigned int n_eval_points =
fe_patch_values.get_function_values(
*vector,
- // reinterpret output argument type; because of
- // the 'if' statement above, this is the
- // identity cast whenever the code is
- // executed, but the cast is necessary
- // to allow compilation even if we don't get here
+ // reinterpret output argument type; because of the 'if' statement
+ // above, this is the identity cast whenever the code is executed,
+ // but the cast is necessary to allow compilation even if we don't
+ // get here
reinterpret_cast<std::vector<typename VectorType::value_type> &>(
patch_values));
}
fe_patch_values.get_function_gradients(
*vector,
- // reinterpret output argument type; because of
- // the 'if' statement above, this is the
- // identity cast whenever the code is
- // executed, but the cast is necessary
- // to allow compilation even if we don't get here
+ // reinterpret output argument type; because of the 'if' statement
+ // above, this is the identity cast whenever the code is executed,
+ // but the cast is necessary to allow compilation even if we don't
+ // get here
reinterpret_cast<std::vector<
std::vector<Tensor<1,
DoFHandlerType::space_dimension,
else
{
// OK, so we know that the data type stored by the user-provided
- // vector is not simply a double. In that case, we need to
- // ask the FEValuesBase object to extract function values for
- // us from the evaluation points in the provided data
- // type, and then copy them by hand into the output location.
+ // vector is not simply a double. In that case, we need to ask the
+ // FEValuesBase object to extract function values for us from the
+ // evaluation points in the provided data type, and then copy them by
+ // hand into the output location.
const unsigned int n_components =
fe_patch_values.get_fe().n_components();
const unsigned int n_eval_points =
fe_patch_values.get_function_gradients(
*vector,
- // reinterpret output argument type; because of
- // the 'if' statement above, this is the
- // identity cast whenever the code is
- // executed, but the cast is necessary
- // to allow compilation even if we don't get here
+ // reinterpret output argument type; because of the 'if' statement
+ // above, this is the identity cast whenever the code is executed,
+ // but the cast is necessary to allow compilation even if we don't
+ // get here
reinterpret_cast<
std::vector<Tensor<1,
DoFHandlerType::space_dimension,
fe_patch_values.get_function_hessians(
*vector,
- // reinterpret output argument type; because of
- // the 'if' statement above, this is the
- // identity cast whenever the code is
- // executed, but the cast is necessary
- // to allow compilation even if we don't get here
+ // reinterpret output argument type; because of the 'if' statement
+ // above, this is the identity cast whenever the code is executed,
+ // but the cast is necessary to allow compilation even if we don't
+ // get here
reinterpret_cast<std::vector<
std::vector<Tensor<2,
DoFHandlerType::space_dimension,
else
{
// OK, so we know that the data type stored by the user-provided
- // vector is not simply a double. In that case, we need to
- // ask the FEValuesBase object to extract function values for
- // us from the evaluation points in the provided data
- // type, and then copy them by hand into the output location.
+ // vector is not simply a double. In that case, we need to ask the
+ // FEValuesBase object to extract function values for us from the
+ // evaluation points in the provided data type, and then copy them by
+ // hand into the output location.
const unsigned int n_components =
fe_patch_values.get_fe().n_components();
const unsigned int n_eval_points =
fe_patch_values.get_function_hessians(
*vector,
- // reinterpret output argument type; because of
- // the 'if' statement above, this is the
- // identity cast whenever the code is
- // executed, but the cast is necessary
- // to allow compilation even if we don't get here
+ // reinterpret output argument type; because of the 'if' statement
+ // above, this is the identity cast whenever the code is executed,
+ // but the cast is necessary to allow compilation even if we don't
+ // get here
reinterpret_cast<
std::vector<Tensor<2,
DoFHandlerType ::space_dimension,
DataOut_DoFData<DoFHandlerType, patch_dim, patch_space_dim>::~DataOut_DoFData()
{
// virtual functions called in constructors and destructors never use the
- // override in a derived class
- // for clarity be explicit on which function is called
+ // override in a derived class for clarity be explicit on which function is
+ // called
DataOut_DoFData<DoFHandlerType, patch_dim, patch_space_dim>::clear();
}
const
{
std::vector<std::string> names;
- // collect the names of dof
- // and cell data
+ // collect the names of dof and cell data
typedef typename std::vector<std::shared_ptr<
internal::DataOutImplementation::DataEntryBase<DoFHandlerType>>>::
const_iterator data_iterator;
unsigned int output_component = 0;
for (data_iterator d = dof_data.begin(); d != dof_data.end(); ++d)
for (unsigned int i = 0; i < (*d)->n_output_variables;)
- // see what kind of data we have
- // here. note that for the purpose of
- // the current function all we care
- // about is vector data
+ // see what kind of data we have here. note that for the purpose of the
+ // current function all we care about is vector data
if ((*d)->data_component_interpretation[i] ==
DataComponentInterpretation::component_is_part_of_vector)
{
- // ensure that there is a
- // continuous number of next
- // space_dim components that all
- // deal with vectors
+ // ensure that there is a continuous number of next space_dim
+ // components that all deal with vectors
Assert(i + patch_space_dim <= (*d)->n_output_variables,
Exceptions::DataOutImplementation::ExcInvalidVectorDeclaration(
i, (*d)->names[i]));
Exceptions::DataOutImplementation::ExcInvalidVectorDeclaration(
i, (*d)->names[i]));
- // all seems alright, so figure out
- // whether there is a common name
- // to these components. if not,
- // leave the name empty and let the
- // output format writer decide what
- // to do here
+ // all seems alright, so figure out whether there is a common name to
+ // these components. if not, leave the name empty and let the output
+ // format writer decide what to do here
std::string name = (*d)->names[i];
for (unsigned int dd = 1; dd < patch_space_dim; ++dd)
if (name != (*d)->names[i + dd])
break;
}
- // finally add a corresponding
- // range
+ // finally add a corresponding range
std::tuple<unsigned int, unsigned int, std::string> range(
output_component, output_component + patch_space_dim - 1, name);
ranges.push_back(range);
- // increase the 'component' counter
- // by the appropriate amount, same
- // for 'i', since we have already
- // dealt with all these components
+ // increase the 'component' counter by the appropriate amount, same
+ // for 'i', since we have already dealt with all these components
output_component += patch_space_dim;
i += patch_space_dim;
}
projects / dealii.git / commitdiff