// $Id$
// Version: $Name$
//
-// std::copyright (C) 1998, 1999, 2000, 2001, 2002 by Wolfgang Bangerth
+// std::copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 by Wolfgang Bangerth
//
// This file is subject to QPL and may not be distributed
// without std::copyright and license information. Please refer
template <typename number>
inline number sqr (const number a) {
return a*a;
-};
+}
/**
time(0),
time_step(0),
step_no(0)
-{};
+{}
template <int dim>
Vector<double> &j2) {
j1.reinit (dof->n_dofs());
j2.reinit (dof->n_dofs());
-};
+}
template <int dim>
Vector<double> &final_v_bar) {
final_u_bar.reinit (dof->n_dofs());
final_v_bar.reinit (dof->n_dofs());
-};
+}
template <int dim>
bool DualFunctional<dim>::use_primal_solutions () const {
return use_primal_problem;
-};
+}
template <int dim>
bool DualFunctional<dim>::use_primal_solutions_at_endtime () const {
return use_primal_problem_at_endtime;
-};
+}
template <int dim>
u = &primal_problem.u;
v = &primal_problem.v;
-};
+}
template <int dim>
0 :
dual_problem.get_forward_timestep());
step_no = dual_problem.timestep_no;
-};
+}
/* ----------------------- EndEnergy ------------------------------*/
template <int dim>
EndEnergy<dim>::EndEnergy (const bool use_primal_problem) :
- DualFunctional<dim> (use_primal_problem, true) {};
+ DualFunctional<dim> (use_primal_problem, true) {}
template <int dim>
Vector<double> &final_u_bar,
Vector<double> &final_v_bar) const {
const double y_offset = 300000000;
- const unsigned int n_q_points = quadrature->n_quadrature_points;
- const unsigned int dofs_per_cell = fe->dofs_per_cell;
+ const unsigned int n_q_points = this->quadrature->n_quadrature_points;
+ const unsigned int dofs_per_cell = this->fe->dofs_per_cell;
- final_u_bar.reinit (dof->n_dofs());
- final_v_bar.reinit (dof->n_dofs());
+ final_u_bar.reinit (this->dof->n_dofs());
+ final_v_bar.reinit (this->dof->n_dofs());
typename DoFHandler<dim>::active_cell_iterator cell, primal_cell, endc;
- cell = dof->begin_active ();
- endc = dof->end ();
- primal_cell = primal_dof->begin_active();
+ cell = this->dof->begin_active ();
+ endc = this->dof->end ();
+ primal_cell = this->primal_dof->begin_active();
- FEValues<dim> fe_values (*fe, *quadrature,
+ FEValues<dim> fe_values (*this->fe, *this->quadrature,
UpdateFlags(update_values |
update_gradients |
update_JxW_values |
update_q_points));
- FEValues<dim> fe_values_primal (*primal_fe, *quadrature,
+ FEValues<dim> fe_values_primal (*this->primal_fe, *this->quadrature,
UpdateFlags(update_values | update_gradients));
FullMatrix<double> cell_matrix (dofs_per_cell, dofs_per_cell);
std::vector<Tensor<1,dim> > local_u_grad (n_q_points);
std::vector<double> local_v (n_q_points);
- std::vector<double> density_values(quadrature->n_quadrature_points);
- std::vector<double> stiffness_values(quadrature->n_quadrature_points);
+ std::vector<double> density_values(this->quadrature->n_quadrature_points);
+ std::vector<double> stiffness_values(this->quadrature->n_quadrature_points);
std::vector<unsigned int> cell_dof_indices (dofs_per_cell);
fe_values.reinit (cell);
fe_values_primal.reinit (primal_cell);
- fe_values_primal.get_function_values (*v, local_v);
- fe_values_primal.get_function_grads (*u, local_u_grad);
+ fe_values_primal.get_function_values (*this->v, local_v);
+ fe_values_primal.get_function_grads (*this->u, local_u_grad);
- density->value_list (fe_values.get_quadrature_points(),
+ this->density->value_list (fe_values.get_quadrature_points(),
density_values);
- stiffness->value_list (fe_values.get_quadrature_points(),
+ this->stiffness->value_list (fe_values.get_quadrature_points(),
stiffness_values);
std::vector<double> local_functional1 (dofs_per_cell, 0);
final_v_bar(cell_dof_indices[shape_func]) += local_functional2[shape_func];
};
};
-};
+}
/*------------------------ IntegrateValueAtOrigin --------------------------------*/
template <int dim>
void IntegratedValueAtOrigin<dim>::compute_functionals (Vector<double> &j1,
Vector<double> &j2) {
- j1.reinit (dof->n_dofs());
- j2.reinit (dof->n_dofs());
+ j1.reinit (this->dof->n_dofs());
+ j2.reinit (this->dof->n_dofs());
- typename DoFHandler<dim>::active_cell_iterator cell = dof->begin_active(),
- endc = dof->end();
+ typename DoFHandler<dim>::active_cell_iterator cell = this->dof->begin_active(),
+ endc = this->dof->end();
Point<dim> origin;
};
Assert (origin_found, ExcVertexNotFound());
-};
+}
/*------------------------ SeismicSignal --------------------------------*/
Vector<double> &)
{
Assert (false, ExcNotImplemented());
-};
+}
template <int dim>
const unsigned int n_q_points = quadrature_face->n_quadrature_points;
const unsigned int dofs_per_cell = fe->dofs_per_cell;
- j1.reinit (dof->n_dofs());
- j2.reinit (dof->n_dofs());
+ j1.reinit (this->dof->n_dofs());
+ j2.reinit (this->dof->n_dofs());
typename DoFHandler<dim>::active_cell_iterator cell, endc;
typename DoFHandler<dim>::face_iterator face;
- cell = dof->begin_active();
- endc = dof->end();
+ cell = this->dof->begin_active();
+ endc = this->dof->end();
std::vector<unsigned int> cell_dof_indices (dofs_per_cell);
for (unsigned int shape_func=0; shape_func<dofs_per_cell; ++shape_func)
j1(cell_dof_indices[shape_func]) += local_integral[shape_func];
};
-};
+}
/*------------------------ EarthSurface --------------------------------*/
Vector<double> &)
{
Assert (false, ExcNotImplemented());
-};
+}
template <int dim>
void EarthSurface<dim>::compute_functionals (Vector<double> &j1,
Vector<double> &j2) {
- const unsigned int face_dofs = fe->dofs_per_face;
+ const unsigned int face_dofs = this->fe->dofs_per_face;
j1.reinit (dof->n_dofs());
j2.reinit (dof->n_dofs());
for (unsigned int shape_func=0; shape_func<face_dofs; ++shape_func)
j1(face_dof_indices[shape_func]) = h;
};
-};
+}
/*------------------------ SplitSignal --------------------------------*/
Vector<double> &)
{
Assert (false, ExcInternalError());
-};
+}
template <int dim>
j1(dof_indices[i]) += sum * time_step / 2;
};
};
-};
+}
/* ------------------------------ Split line 1d case ----------------------------- */
void SplitLine<dim>::compute_endtime_vectors (Vector<double> &,
Vector<double> &) {
Assert (false, ExcNotImplemented ());
-};
+}
#if 2 == 1
j1(dof_indices[i]) += sum;
};
};
-};
+}
/*------------------------ SecondCrossing --------------------------------*/
j1(dof_indices[i]) += sum / time_step;
};
};
-};
+}
/*------------------------ HuyghensWave --------------------------------*/
};
AssertThrow (point_found, ExcInternalError());
-};
+}
time (0),
time_step (0),
step_no (0)
-{};
+{}
template <int dim>
base_file_name = target.parameters.output_directory +
"sweep"+int_to_string(target.sweep_no, 2) + "/evaluation/" +
int_to_string(step_no,4);
-};
+}
template <int dim>
-void EvaluationBase<dim>::reset () {};
+void EvaluationBase<dim>::reset () {}
template <int dim>
-void EvaluationBase<dim>::print_final_result (std::ostream &) {};
+void EvaluationBase<dim>::print_final_result (std::ostream &) {}
template <int dim>
double EvaluationBase<dim>::get_final_result () {
return 0;
-};
+}
/*--------------------------- EvaluateEnergyContent ----------------------*/
template <int dim>
EvaluateEnergyContent<dim>::EvaluateEnergyContent () :
old_energy (0),
- integrated_outflux (0) {};
+ integrated_outflux (0) {}
template <int dim>
void EvaluateEnergyContent<dim>::reset () {
old_energy = 0;
integrated_outflux = 0;
-};
+}
template <int dim>
};
return total_energy;
-};
+}
/* ---------------------------- EvaluateIntegratedValueAtOrigin ------------------- */
void EvaluateIntegratedValueAtOrigin<dim>::print_final_result (std::ostream &out) {
out << " Integrated value of u at origin: "
<< integrated_value << std::endl;
-};
+}
template <int dim>
double EvaluateIntegratedValueAtOrigin<dim>::get_final_result () {
return integrated_value;
-};
+}
template <int dim>
std::string EvaluateIntegratedValueAtOrigin<dim>::description () const {
return "integrated value at origin";
-};
+}
template <int dim>
void EvaluateIntegratedValueAtOrigin<dim>::reset () {
integrated_value = 0;
-};
+}
template <int dim>
integrated_value += value_at_origin * time_step;
return value_at_origin;
-};
+}
/*------------------------- EvaluateSeismicSignal --------------------------*/
template <int dim>
void EvaluateSeismicSignal<dim>::print_final_result (std::ostream &out) {
out << " Integrated seismic signal: " << result << std::endl;
-};
+}
template <int dim>
double EvaluateSeismicSignal<dim>::get_final_result () {
return result;
-};
+}
template <int dim>
std::string EvaluateSeismicSignal<dim>::description () const {
return "Integrated seismic signal at top";
-};
+}
template <int dim>
void EvaluateSeismicSignal<dim>::reset () {
result = 0;
-};
+}
template <>
{
Assert (false, ExcNotImplemented());
return 0;
-};
+}
template <int dim>
result += u_integrated*time_step;
return u_integrated;
-};
+}
/*------------------------- EvaluateSplitSignal --------------------------*/
template <int dim>
void EvaluateSplitSignal<dim>::print_final_result (std::ostream &out) {
out << " Integrated split signal: " << result << std::endl;
-};
+}
template <int dim>
double EvaluateSplitSignal<dim>::get_final_result () {
return result;
-};
+}
template <int dim>
std::string EvaluateSplitSignal<dim>::description () const {
return "Integrated split signal (exact: (2+pi)/(16-pi)=0.010229)";
-};
+}
template <int dim>
void EvaluateSplitSignal<dim>::reset () {
result = 0;
-};
+}
template <>
{
Assert (false, ExcNotImplemented());
return 0;
-};
+}
template <int dim>
result += u_integrated*time_step / 2;
return u_integrated;
-};
+}
/*------------------------- EvaluateOneBranch1d --------------------------*/
template <int dim>
void EvaluateOneBranch1d<dim>::print_final_result (std::ostream &out) {
out << " One branch integrated: " << result << std::endl;
-};
+}
template <int dim>
double EvaluateOneBranch1d<dim>::get_final_result () {
return result;
-};
+}
template <int dim>
std::string EvaluateOneBranch1d<dim>::description () const {
return "One branch integrated (exact: 0.055735)";
-};
+}
template <int dim>
void EvaluateOneBranch1d<dim>::reset () {
result = 0;
-};
+}
template <int dim>
{
Assert (false, ExcNotImplemented());
return 0;
-};
+}
#if 2 == 1
template <int dim>
void EvaluateSecondCrossing1d<dim>::print_final_result (std::ostream &out) {
out << " Second crossing: " << result << std::endl;
-};
+}
template <int dim>
double EvaluateSecondCrossing1d<dim>::get_final_result () {
return result;
-};
+}
template <int dim>
std::string EvaluateSecondCrossing1d<dim>::description () const {
return "Second crossing (exact: 0.011147)";
-};
+}
template <int dim>
void EvaluateSecondCrossing1d<dim>::reset () {
result = 0;
-};
+}
template <int dim>
{
Assert (false, ExcNotImplemented());
return 0;
-};
+}
#if 2 == 1
void EvaluateHuyghensWave<dim>::print_final_result (std::ostream &out) {
out << " Hughens wave -- weighted time: " << weighted_value / integrated_value << std::endl;
out << " average : " << integrated_value << std::endl;
-};
+}
template <int dim>
double EvaluateHuyghensWave<dim>::get_final_result () {
return weighted_value / integrated_value;
-};
+}
template <int dim>
std::string EvaluateHuyghensWave<dim>::description () const {
return "Huyghens wave";
-};
+}
template <int dim>
void EvaluateHuyghensWave<dim>::reset () {
integrated_value = weighted_value = 0;
-};
+}
template <int dim>
};
return value_at_origin;
-};
+}
template class EvaluationBase<2>;
TimeDependent::TimeSteppingData(0,1),
TimeDependent::TimeSteppingData(0,1)),
parameters (parameters)
-{};
+{}
template <int dim>
end_sweep ();
deallog << std::endl << std::endl;
-};
+}
template <int dim>
deallog << " Got " << total_number_of_cells << " presently, expecting "
<< total_expected_cells << " for next sweep." << std::endl;
};
-};
+}
template <int dim>
deallog << std::endl;
};
-};
+}
template <int dim>
data_out_stack.set_flags (eps_flags);
data_out_stack.write (logfile, output_format);
deallog << '.' << std::endl;
-};
+}
template class TimestepManager<2>;
stiffness (0),
dual_functional (0),
coarse_grid (0)
-{};
+{}
template <int dim>
WaveParameters<dim>::~WaveParameters ()
{
delete_parameters ();
-};
+}
template <int dim>
i!=eval_list.end(); ++i)
delete *i;
eval_list.erase (eval_list.begin(), eval_list.end());
-};
+}
template <int dim>
initial_u = functions[0];
initial_v = functions[1];
-};
+}
template <int dim>
}
else
AssertThrow (false, ExcUnknownName (name));
-};
+}
template <int dim>
}
else
AssertThrow (false, ExcUnknownName (name));
-};
+}
template <int dim>
else
AssertThrow (false, ExcUnknownName (name));
};
-};
+}
template <int dim>
dual_functional = new HuyghensWave<dim> ();
else
AssertThrow (false, ExcUnknownName (name));
-};
+}
#if 2 == 1
default:
Assert (false, ExcInternalError());
};
-};
+}
#endif
prm.declare_entry ("Refinement criterion", "energy estimator",
Patterns::Selection ("energy estimator|dual estimator"));
prm.declare_entry ("Sweeps", "3", Patterns::Integer());
-};
+}
template <int dim>
prm.enter_subsection ("Grid");
make_coarse_grid (prm.get("Coarse mesh"));
prm.leave_subsection ();
-};
+}
template class WaveParameters<2>;
data_out_stack = new DataOutStack<dim>();
else
data_out_stack = 0;
-};
+}
template <int dim>
if (data_out_stack != 0)
delete data_out_stack;
data_out_stack = 0;
-};
+}
template class SweepData<2>;
SweepInfo::get_data ()
{
return data;
-};
+}
SweepInfo::Timers &
SweepInfo::get_timers ()
{
return timers;
-};
+}
template <int dim>
<< int_to_string (time->tm_hour, 2) << ":"
<< int_to_string (time->tm_min, 2) << ":"
<< int_to_string (time->tm_sec, 2) << std::endl;
-};
+}
SweepInfo::Data::Data () :
cells (0),
primal_dofs (0),
dual_dofs (0)
-{};
+{}
template
TimeStepBase_Wave<dim>::TimeStepBase_Wave ():
TimeStepBase_Tria<dim> (),
parameters (*static_cast<WaveParameters<dim>*>(0))
-{};
+{}
template <int dim>
WaveParameters<dim>::dual_estimator),
true)),
parameters (parameters)
-{};
+{}
template <int dim>
TimeStepBase_Wave<dim>::get_timestep_primal () const
{
return dynamic_cast<const TimeStep_Primal<dim> &> (*this);
-};
+}
template <int dim>
TimeStepBase_Wave<dim>::get_timestep_dual () const
{
return dynamic_cast<const TimeStep_Dual<dim> &> (*this);
-};
+}
template <int dim>
TimeStepBase_Wave<dim>::get_timestep_postprocess () const
{
return dynamic_cast<const TimeStep_Postprocess<dim> &> (*this);
-};
+}
template <int dim>
branch_signature + 's' +
int_to_string (sweep_no, 2) + 't' +
int_to_string (timestep_no, 4));
-};
+}
template <int dim>
void TimeStepBase_Wave<dim>::attach_sweep_info (SweepInfo &si)
{
sweep_info = &si;
-};
+}
template <int dim>
void TimeStepBase_Wave<dim>::attach_sweep_data (SweepData<dim> &sd)
{
sweep_data = &sd;
-};
+}
/* --------------------------------------------------------------*/
quadrature (FEHelper<dim>::get_quadrature(fe_name)),
quadrature_face (FEHelper<dim>::get_quadrature_face(fe_name)),
statistic_data()
-{};
+{}
template <int dim>
Assert (laplace_matrix.empty(), ExcInternalError());
Assert (u.size() ==0, ExcInternalError());
Assert (v.size() ==0, ExcInternalError());
-};
+}
template <int dim>
Assert (false, ExcInternalError());
};
};
-};
+}
template <int dim>
default:
Assert (false, ExcInternalError());
};
-};
+}
template <int dim>
{
std::string tmp_filename = tmp_filename_base(branch_signature());
remove (tmp_filename.c_str());
-};
+}
template <int dim>
constraints.distribute (solution);
return control.last_step();
-};
+}
template <int dim>
cell_laplace_matrix(i,j));
};
};
-};
+}
template <int dim>
transfer_old_solutions (old_cell, new_cell,
*old_grid_u, *old_grid_v,
old_u, old_v);
-};
+}
template <int dim>
old_cell->get_interpolated_dof_values (old_grid_v, cell_data);
new_cell->set_dof_values_by_interpolation (cell_data, old_v);
};
-};
+}
template <int dim>
};
return energy;
-};
+}
template <int dim>
n_solver_steps_helmholtz (0),
n_solver_steps_projection (0),
energy (std::make_pair(0.0, 0.0))
-{};
+{}
template <int dim>
n_solver_steps_helmholtz (n_solver_steps_helmholtz),
n_solver_steps_projection (n_solver_steps_projection),
energy (energy)
-{};
+{}
template <int dim>
<< "# elastic energy" << std::endl
<< "# kinetic energy" << std::endl
<< "# total energy" << std::endl;
-};
+}
template <int dim>
<< energy.first << ' '
<< energy.second << ' '
<< energy.first+energy.second;
-};
+}
template class TimeStepBase_Wave<2>;
TimeStep_Dual<dim>::TimeStep_Dual (const std::string &dual_fe)
:
TimeStep_Wave<dim> (dual_fe)
-{};
+{}
template <int dim>
0, 0,
std::make_pair (0.0, 0.0));
deallog << "." << std::endl;
-};
+}
template <int dim>
compute_energy ());
deallog << "." << std::endl;
-};
+}
template <int dim>
else
do_timestep ();
sweep_info->get_timers().dual_problem.stop();
-};
+}
template <int dim>
std::string TimeStep_Dual<dim>::branch_signature () const
{
return "d";
-};
+}
template <int dim>
create_matrices ();
};
sweep_info->get_timers().dual_problem.stop();
-};
+}
template <int dim>
right_hand_side2.add (timestep, dual1);
constraints.condense (right_hand_side1);
-};
+}
template <int dim>
build_rhs (old_cell, new_cell,
fe_values,
right_hand_side1, right_hand_side2);
-};
+}
template <int dim>
};
Assert (false, ExcInternalError());
-};
+}
template <int dim>
};
return level_difference;
-};
+}
template <int dim>
};
return level_difference;
-};
+}
template class TimeStep_Dual<2>;
template <int dim>
TimeStep_ErrorEstimation<dim>::TimeStep_ErrorEstimation ()
-{};
+{}
template <int dim>
sweep_info->get_data().accumulated_error += accumulated_error;
sweep_info->get_timers().error_estimation.stop();
-};
+}
template <int dim>
estimated_error_per_cell.reinit (tria->n_active_cells());
};
-};
+}
template <int dim>
estimated_error_per_cell.reinit (0);
};
-};
+}
template <int dim>
get_error_indicators (indicators);
for (Vector<float>::iterator i=indicators.begin(); i!=indicators.end(); ++i)
*i = fabs(*i);
-};
+}
template <int dim>
{
std::ifstream in (tmp_filename_base(branch_signature()).c_str());
indicators.block_read (in);
-};
+}
template <int dim>
parameters.density);
estimated_error_per_cell += v_estimator;
};
-};
+}
template <int dim>
*i = error_on_this_cell->sum();
total_estimated_error += *error_on_this_cell;
};
-};
+}
template <int dim>
Assert (false, ExcInternalError());
-};
+}
template <int dim>
++cellwise_error.next_free_slot;
};
};
-};
+}
template <int dim>
};
return error_sum;
-};
+}
template <int dim>
local_difference_u_bar_old,
local_difference_v_bar_old,
fe_values);
-};
+}
template <int dim>
return error_on_cell;
-};
+}
#include <fe/fe_tools.h>
for (unsigned int i=0; i<dual_fe.dofs_per_cell; ++i)
difference_matrix(i,i) = 1.;
difference_matrix.add (-1, interpolation_matrix);
-};
+}
template <int dim>
TimeStep_ErrorEstimation<dim>::StatisticData::StatisticData () :
estimated_error (0)
-{};
+{}
template <int dim>
TimeStep_ErrorEstimation<dim>::StatisticData::StatisticData (const double estimated_error) :
estimated_error (estimated_error)
-{};
+{}
template <int dim>
void TimeStep_ErrorEstimation<dim>::StatisticData::write_descriptions (std::ostream &out)
{
out << "# total estimated error in this timestep" << std::endl;
-};
+}
template <int dim>
void TimeStep_ErrorEstimation<dim>::StatisticData::write (std::ostream &out) const
{
out << estimated_error*100000;
-};
+}
template <int dim>
TimeStep_ErrorEstimation<dim>::ErrorOnCell::ErrorOnCell () {
for (unsigned int i=0; i<sizeof(part)/sizeof(part[0]); ++i)
part[i] = 0;
-};
+}
template <int dim>
for (unsigned int i=0; i<sizeof(part)/sizeof(part[0]); ++i)
part[i] += eoc.part[i];
return *this;
-};
+}
template <int dim>
for (unsigned int i=0; i<sizeof(part)/sizeof(part[0]); ++i)
x += part[i];
return x;
-};
+}
template <int dim>
TimeStep_ErrorEstimation<dim>::CellwiseError::CellwiseError (const unsigned int n_errors) :
errors (n_errors),
next_free_slot (&*errors.begin())
-{};
+{}
template class TimeStep_ErrorEstimation<2>;
parameters),
TimeStep_Primal<dim>(parameters.primal_fe),
TimeStep_Dual<dim> (parameters.dual_fe)
-{};
+{}
template <int dim>
default:
Assert (false, ExcInternalError());
};
-};
+}
template <int dim>
sweep_info->get_timers().grid_generation.start();
TimeStepBase_Wave<dim>::sleep (sleep_level);
sweep_info->get_timers().grid_generation.stop();
-};
+}
template <int dim>
TimeStep_Primal<dim>::end_sweep ();
TimeStep_Dual<dim>::end_sweep ();
TimeStep_Postprocess<dim>::end_sweep ();
-};
+}
template <int dim>
out << "# Postprocessing:" << std::endl;
TimeStep_Postprocess<dim>::StatisticData::write_descriptions (out, parameters);
};
-};
+}
template <int dim>
TimeStep_ErrorEstimation<dim>::statistic_data.write (out);
out << " ";
TimeStep_Postprocess<dim>::statistic_data.write (out);
-};
+}
template class TimeStep<2>;
deallog << std::endl;
sweep_info->get_timers().postprocessing.stop();
-};
+}
template <int dim>
void TimeStep_Postprocess<dim>::wake_up (const unsigned int wakeup_level)
{
TimeStep_ErrorEstimation<dim>::wake_up (wakeup_level);
-};
+}
template <int dim>
void TimeStep_Postprocess<dim>::sleep (const unsigned int sleep_level)
{
TimeStep_ErrorEstimation<dim>::sleep (sleep_level);
-};
+}
template <int dim>
std::string TimeStep_Postprocess<dim>::branch_signature () const
{
return "o";
-};
+}
template <int dim>
{
std::string tmp_filename = tmp_filename_base(branch_signature());
remove (tmp_filename.c_str());
-};
+}
template <int dim>
interpolated_u_bar(primal_vertex_index) = target.u(dual_vertex_index);
interpolated_v_bar(primal_vertex_index) = target.v(dual_vertex_index);
};
-};
+}
template <int dim>
for (typename std::list<EvaluationBase<dim>*>::const_iterator i = parameters.eval_list.begin();
i != parameters.eval_list.end(); ++i)
out << "# " << (*i)->description() << std::endl;
-};
+}
template <int dim>
{
for (unsigned int i=0; i<evaluation_results.size(); ++i)
out << evaluation_results[i]*100000 << ' ';
-};
+}
template class TimeStep_Postprocess<2>;
TimeStep_Primal<dim>::TimeStep_Primal (const std::string &primal_fe)
:
TimeStep_Wave<dim> (primal_fe)
-{};
+{}
template <int dim>
std::make_pair (0.0, 0.0));
deallog << "." << std::endl;
-};
+}
template <int dim>
compute_energy ());
deallog << "." << std::endl;
-};
+}
template <int dim>
else
do_timestep ();
sweep_info->get_timers().primal_problem.stop();
-};
+}
template <int dim>
std::string TimeStep_Primal<dim>::branch_signature () const
{
return "p";
-};
+}
template <int dim>
create_matrices ();
};
sweep_info->get_timers().primal_problem.stop();
-};
+}
template <int dim>
build_rhs (right_hand_side1, right_hand_side2);
constraints.condense (right_hand_side1);
-};
+}
template <int dim>
build_rhs (old_cell, new_cell,
fe_values,
right_hand_side1, right_hand_side2);
-};
+}
template <int dim>
};
Assert (false, ExcInternalError());
-};
+}
template <int dim>
};
return level_difference;
-};
+}
template <int dim>
};
return level_difference;
-};
+}
template class TimeStep_Primal<2>;
dst = src;
return;
};
-};
+}
#include <fe/mapping_q1.h>
-const FE_Q<2> FEHelper<2>::fe_linear(1);
-const FE_Q<2> FEHelper<2>::fe_quadratic_sub(2);
+const FE_Q<2> FEHelper<2>::fe_linear(1)
+const FE_Q<2> FEHelper<2>::fe_quadratic_sub(2)
#if 2 < 3
-const FE_Q<2> FEHelper<2>::fe_cubic_sub(3);
-const FE_Q<2> FEHelper<2>::fe_quartic_sub(4);
+const FE_Q<2> FEHelper<2>::fe_cubic_sub(3)
+const FE_Q<2> FEHelper<2>::fe_quartic_sub(4)
#endif
const QGauss2<2> FEHelper<2>::q_gauss_2;
Assert (false, ExcInternalError());
return fe_linear;
-};
+}
template <int dim>
Assert (false, ExcInternalError());
return q_gauss_2;
-};
+}
template <>
const Quadrature<0> &FEHelper<1>::get_quadrature_face (const std::string &) {
static const Quadrature<0> dummy_quadrature(1);
return dummy_quadrature;
-};
+}
template <int dim>
Assert (false, ExcInternalError());
return q_gauss_2_face;
-};
+}
std::string int_to_string (const unsigned int i, const unsigned int digits) {
s += "invalid digits information";
};
return s;
-};
+}
template class FEHelper<2>;
template <int dim>
WaveProblem<dim>::WaveProblem ()
-{};
+{}
template <int dim>
WaveProblem<dim>::~WaveProblem ()
-{};
+{}
template <int dim>
void WaveProblem<dim>::declare_parameters (ParameterHandler &prm)
{
parameters.declare_parameters (prm);
-};
+}
template <int dim>
void WaveProblem<dim>::parse_parameters (ParameterHandler &prm)
{
parameters.parse_parameters (prm);
-};
+}
template <int dim>
void WaveProblem<dim>::create_new (const unsigned int)
{
parameters.delete_parameters ();
-};
+}
template <int dim>
for (unsigned int sweep=0; sweep<parameters.number_of_sweeps; ++sweep)
timestep_manager.run_sweep (sweep);
-};
+}
int main ()
return 0;
-};
+}