This is the entire code: 

#include <deal.II/grid/tria.h>
#include <deal.II/dofs/dof_handler.h>

#include <deal.II/grid/grid_generator.h>


#include <deal.II/grid/tria_accessor.h>
#include <deal.II/grid/tria_iterator.h>
#include <deal.II/dofs/dof_accessor.h>

#include <deal.II/fe/fe_q.h>

#include <deal.II/dofs/dof_tools.h>

#include <deal.II/fe/fe_values.h>
#include <deal.II/base/quadrature_lib.h>

#include <deal.II/base/function.h>
#include <deal.II/numerics/vector_tools.h>
#include <deal.II/numerics/matrix_tools.h>


#include <deal.II/lac/vector.h>
#include <deal.II/lac/full_matrix.h>
#include <deal.II/lac/sparse_matrix.h>
#include <deal.II/lac/compressed_sparsity_pattern.h>
#include <deal.II/lac/solver_cg.h>
#include <deal.II/lac/precondition.h>


#include <deal.II/numerics/data_out.h>
#include <fstream>
#include <iostream>


using namespace dealii;


class Step3
{
public:
  Step3 ();

  void run ();



private:
  void make_grid ();
  void setup_system ();
  void assemble_system ();
  void solve ();
  void output_results () const;


  Triangulation<2>     triangulation;
  FE_Q<2>              fe;
  DoFHandler<2>        dof_handler;


  SparsityPattern      sparsity_pattern;
  SparseMatrix<double> system_matrix;

  Vector<double>       solution;
  Vector<double>       system_rhs;
};

Step3::Step3 ()
  :
  fe (1),
  dof_handler (triangulation)
{}



void Step3::make_grid ()
{
  GridGenerator::hyper_cube (triangulation, -1, 1);
  triangulation.begin_active()->face(0)->set_boundary_id(1);
  triangulation.refine_global (5);

  std::cout << "Number of active cells: "
            << triangulation.n_active_cells()
            << std::endl;
}


void Step3::setup_system ()
{
  dof_handler.distribute_dofs (fe);
  std::cout << "Number of degrees of freedom: "
            << dof_handler.n_dofs()
            << std::endl;

  CompressedSparsityPattern c_sparsity(dof_handler.n_dofs());
  DoFTools::make_sparsity_pattern (dof_handler, c_sparsity);
  sparsity_pattern.copy_from(c_sparsity);


  system_matrix.reinit (sparsity_pattern);

  solution.reinit (dof_handler.n_dofs());
  system_rhs.reinit (dof_handler.n_dofs());
}


void Step3::assemble_system ()
{

  QGauss<2>  quadrature_formula(2);

  FEValues<2> fe_values (fe, quadrature_formula,
                         update_values | update_gradients | 
update_JxW_values);

  const unsigned int   dofs_per_cell = fe.dofs_per_cell;
  const unsigned int   n_q_points    = quadrature_formula.size();

  FullMatrix<double>   cell_matrix (dofs_per_cell, dofs_per_cell);
  Vector<double>       cell_rhs (dofs_per_cell);


  std::vector<types::global_dof_index> local_dof_indices (dofs_per_cell);


  DoFHandler<2>::active_cell_iterator
  cell = dof_handler.begin_active(),
  endc = dof_handler.end();
  for (; cell!=endc; ++cell)
    {

      fe_values.reinit (cell);

      cell_matrix = 0;
      cell_rhs = 0;


      for (unsigned int q_index=0; q_index<n_q_points; ++q_index)
        {

          for (unsigned int i=0; i<dofs_per_cell; ++i)
            for (unsigned int j=0; j<dofs_per_cell; ++j)
              cell_matrix(i,j) += (fe_values.shape_grad (i, q_index) *
                                   fe_values.shape_grad (j, q_index) *
                                   fe_values.JxW (q_index));


          for (unsigned int i=0; i<dofs_per_cell; ++i)
            cell_rhs(i) += (fe_values.shape_value (i, q_index) *
                            1 *
                            fe_values.JxW (q_index));
        }

      cell->get_dof_indices (local_dof_indices);


      for (unsigned int i=0; i<dofs_per_cell; ++i)
        for (unsigned int j=0; j<dofs_per_cell; ++j)
          system_matrix.add (local_dof_indices[i],
                             local_dof_indices[j],
                             cell_matrix(i,j));


      for (unsigned int i=0; i<dofs_per_cell; ++i)
        system_rhs(local_dof_indices[i]) += cell_rhs(i);
    }


  std::map<types::global_dof_index,double> boundary_values;
  VectorTools::interpolate_boundary_values (dof_handler,
                                            1,
                                            ConstantFunction<2>(1.),
                                            boundary_values);

  MatrixTools::apply_boundary_values (boundary_values,
                                      system_matrix,
                                      solution,
                                      system_rhs);
}



void Step3::solve ()
{

  SolverControl           solver_control (1000, 1e-12);

  SolverCG<>              solver (solver_control);


  solver.solve (system_matrix, solution, system_rhs,
                PreconditionIdentity());

}


void Step3::output_results () const
{

  DataOut<2> data_out;

  data_out.attach_dof_handler (dof_handler);
  data_out.add_data_vector (solution, "solution");

  data_out.build_patches ();

  std::ofstream output("solution.gpl");
  data_out.write_gnuplot (output);
}

void Step3::run ()
{
  make_grid ();
  setup_system ();
  assemble_system ();
  solve ();
  output_results ();
}

int main ()
{
  Step3 laplace_problem;
  laplace_problem.run ();

  return 0;
}

And this is the error:

/home/ubuntu/step-3/step-3.cc: In member function ‘void Step3::make_grid()’:
/home/ubuntu/step-3/step-3.cc:80:42: error: ‘class dealii::TriaAccessor<1, 
2, 2>’ has no member named ‘set_boundary_id’
   triangulation.begin_active()->face(0)->set_boundary_id(1);
                                          ^
make[3]: *** [CMakeFiles/step-3.dir/step-3.cc.o] Error 1
make[2]: *** [CMakeFiles/step-3.dir/all] Error 2
make[1]: *** [CMakeFiles/run.dir/rule] Error 2
make: *** [run] Error 2


Hope this helps
Huzaifa






On Monday, May 11, 2020 at 8:20:58 PM UTC+5:30, Wolfgang Bangerth wrote:
>
> On 5/11/20 3:46 AM, Huzaifa Unjhawala wrote: 
> > I had added the header file prior to the run. For more information, 
> given 
> > below is the snippet of the code : 
> > 
> > void Step3::make_grid () 
> > { 
> >    GridGenerator::hyper_cube (triangulation, -1, 1); 
> >    triangulation.begin_active()->face(0)->set_boundary_id(1); 
> >    triangulation.refine_global (5); 
> > 
> >    std::cout << "Number of active cells: " 
> >              << triangulation.n_active_cells() 
> >              << std::endl; 
> > } 
> > 
> > I then use: 
> > VectorTools::interpolate_boundary_values (dof_handler, 
> >                                              1, 
> >                                              ConstantFunction<2>(1.), 
> >                                              boundary_values); 
> > 
> > 
> > as given in the documentation. 
>
> Huzaifa, 
> it *should* work. Can you post the entire code you're trying to compile, 
> along 
> with the complete error message you get? 
>
> Best 
>   W. 
>
> -- 
> ------------------------------------------------------------------------ 
> Wolfgang Bangerth          email:                 [email protected] 
> <javascript:> 
>                             www: http://www.math.colostate.edu/~bangerth/ 
>
>

-- 
The deal.II project is located at http://www.dealii.org/
For mailing list/forum options, see 
https://groups.google.com/d/forum/dealii?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"deal.II User Group" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to [email protected].
To view this discussion on the web visit 
https://groups.google.com/d/msgid/dealii/ad61bbf1-7774-4816-adb7-76e604d52ffe%40googlegroups.com.

Reply via email to