Rotateable< ELEMENT > Class Template Reference

Inheritance diagram for Rotateable< ELEMENT >:

Public Member Functions
	Rotateable ()
	Constructor, initialise rotation to NULL (default) More...
void	further_build ()
void	rotate (const unsigned &angle)
void	rotate_local_coordinates (Vector< double > &s)
void	output (std::ostream &outfile, const unsigned &nplot)
void	output_fct (std::ostream &outfile, const unsigned &nplot, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt)
void	compute_error (std::ostream &outfile, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt, double &error, double &norm)
	Rotateable ()
	Constructor, initialise rotation to NULL (default) More...
void	further_build ()
void	rotate (const unsigned &angle)
void	rotate_local_coordinates (Vector< double > &s)
void	output (std::ostream &outfile, const unsigned &nplot)
void	output_fct (std::ostream &outfile, const unsigned &nplot, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt)
void	compute_error (std::ostream &outfile, FiniteElement::SteadyExactSolutionFctPt exact_soln_pt, double &error, double &norm)

Private Attributes
unsigned	Rotated
	Integer to store the rotation angle. More...

Detailed Description

template<class ELEMENT>
class Rotateable< ELEMENT >

Class the overloaded RefineablePoissonElements so that the elements that can be rotated about their centre

Constructor & Destructor Documentation

Rotateable() [1/2]

template<class ELEMENT >

Rotateable< ELEMENT >::Rotateable ( )

inline

Constructor, initialise rotation to NULL (default)

: RefineableElement(), ELEMENT(), Rotated(0) { }

Rotateable() [2/2]

template<class ELEMENT >

Rotateable< ELEMENT >::Rotateable ( )

inline

Constructor, initialise rotation to NULL (default)

: RefineableElement(), ELEMENT(), Rotated(0) { }

Member Function Documentation

compute_error() [1/2]

template<class ELEMENT >

void Rotateable< ELEMENT >::compute_error ( std::ostream &  outfile, FiniteElement::SteadyExactSolutionFctPt  exact_soln_pt, double &  error, double &  norm  )

inline

Error computation stuff Overloaded to be identical under rotation

{ 
 // Initialise
 error=0.0;
 norm=0.0;
 
 //Vector of local coordinates
 Vector<double> s(2);
 
 // Vector for coordintes
 Vector<double> x(2);
 
 //Find out how many nodes there are in the element
 unsigned n_node = this->nnode();
 
 Shape psi(n_node);
 
 //Set the value of n_intpt
 unsigned n_intpt = this->integral_pt()->nweight();
  
 // Tecplot 
 outfile << "ZONE" << std::endl;
 
 // Exact solution Vector (here a scalar)
 Vector<double> exact_soln(1);
 
 //Loop over the integration points
 for(unsigned ipt=0;ipt<n_intpt;ipt++)
  {
   
   //Assign values of s
   for(unsigned i=0;i<2;i++)
    {
     s[i] = this->integral_pt()->knot(ipt,i);
    }
 
   //Rotate the coordinates
   this->rotate_local_coordinates(s);
   
   //Get the integral weight
   double w = this->integral_pt()->weight(ipt);
   
   // Get jacobian of mapping
   double J = this->J_eulerian(s);
   
   //Premultiply the weights and the Jacobian
   double W = w*J;
   
   // Get x position as Vector
   this->interpolated_x(s,x);
   
   // Get FE function value
   double u_fe = this->interpolated_u_poisson(s);
   
   // Get exact solution at this point
   (*exact_soln_pt)(x,exact_soln);
   
   //Output x,y,...,error
   for(unsigned i=0;i<2;i++)
    {
     outfile << x[i] << " ";
    }
   outfile << exact_soln[0] << " " << exact_soln[0]-u_fe << std::endl;  
   
   // Add to error and norm
   norm+=exact_soln[0]*exact_soln[0]*W;
   error+=(exact_soln[0]-u_fe)*(exact_soln[0]-u_fe)*W;
  }
  
}

References calibrate::error, ProblemParameters::exact_soln(), i, J, s, w, oomph::QuadTreeNames::W, and plotDoE::x.

compute_error() [2/2]

template<class ELEMENT >

void Rotateable< ELEMENT >::compute_error ( std::ostream &  outfile, FiniteElement::SteadyExactSolutionFctPt  exact_soln_pt, double &  error, double &  norm  )

inline

Error computation stuff Overloaded to be identical under rotation

{ 
 // Initialise
 error=0.0;
 norm=0.0;
 
 //Vector of local coordinates
 Vector<double> s(3);
 
 // Vector for coordintes
 Vector<double> x(3);
 
 //Find out how many nodes there are in the element
 unsigned n_node = this->nnode();
 
 Shape psi(n_node);
 
 //Set the value of n_intpt
 unsigned n_intpt = this->integral_pt()->nweight();
  
 // Tecplot 
 outfile << "ZONE" << std::endl;
 
 // Exact solution Vector (here a scalar)
 Vector<double> exact_soln(1);
 
 //Loop over the integration points
 for(unsigned ipt=0;ipt<n_intpt;ipt++)
  {
   
   //Assign values of s
   for(unsigned i=0;i<3;i++)
    {
     s[i] = this->integral_pt()->knot(ipt,i);
    }
 
   //Rotate the local coordinates
   this->rotate_local_coordinates(s);
   
   //Get the integral weight
   double w = this->integral_pt()->weight(ipt);
   
   // Get jacobian of mapping
   double J = this->J_eulerian(s);
   
   //Premultiply the weights and the Jacobian
   double W = w*J;
   
   // Get x position as Vector
   this->interpolated_x(s,x);
   
   // Get FE function value
   double u_fe = this->interpolated_u_poisson(s);
   
   // Get exact solution at this point
   (*exact_soln_pt)(x,exact_soln);
   
   //Output x,y,...,error
   for(unsigned i=0;i<3;i++)
    {
     outfile << x[i] << " ";
    }
   outfile << exact_soln[0] << " " << exact_soln[0]-u_fe << std::endl;  
   
   // Add to error and norm
   norm+=exact_soln[0]*exact_soln[0]*W;
   error+=(exact_soln[0]-u_fe)*(exact_soln[0]-u_fe)*W;
  }
  
}

References calibrate::error, ProblemParameters::exact_soln(), i, J, s, w, oomph::QuadTreeNames::W, and plotDoE::x.

further_build() [1/2]

template<class ELEMENT >

void Rotateable< ELEMENT >::further_build ( )

inline

Overload the further build function to pass the rotate information to the sons

  {
   ELEMENT::further_build();
   this->Rotated = dynamic_cast<Rotateable<ELEMENT>*>
    (this->father_element_pt())->Rotated;
  }

further_build() [2/2]

template<class ELEMENT >

void Rotateable< ELEMENT >::further_build ( )

inline

Overload the further build function to pass the rotate information to the sons

  {
   ELEMENT::further_build();
   this->Rotated = dynamic_cast<Rotateable<ELEMENT>*>
    (this->father_element_pt())->Rotated;
  }

output() [1/2]

template<class ELEMENT >

void Rotateable< ELEMENT >::output ( std::ostream &  outfile, const unsigned &  nplot  )

inline

Output function overloaded to produce identical output under rotation

{
 //Vector of local coordinates
 Vector<double> s(2);
 
 // Tecplot header info
 outfile << this->tecplot_zone_string(nplot);
 
 // Loop over plot points
 unsigned num_plot_points = this->nplot_points(nplot);
 for (unsigned iplot=0;iplot<num_plot_points;iplot++)
  {
   
   // Get local coordinates of plot point
   this->get_s_plot(iplot,nplot,s);
   //Rotate the coordinates
   this->rotate_local_coordinates(s);
 
   for(unsigned i=0;i<2;i++) 
    {
     outfile << this->interpolated_x(s,i) << " ";
    }
   outfile << this->interpolated_u_poisson(s) << std::endl;   
   
  }
 
 // Write tecplot footer (e.g. FE connectivity lists)
 this->write_tecplot_zone_footer(outfile,nplot);
 
}

References i, and s.

output() [2/2]

template<class ELEMENT >

void Rotateable< ELEMENT >::output ( std::ostream &  outfile, const unsigned &  nplot  )

inline

Output function overloaded to produce identical output under rotation

{
 //Vector of local coordinates
 Vector<double> s(3);
 
 // Tecplot header info
 outfile << this->tecplot_zone_string(nplot);
 
 // Loop over plot points
 unsigned num_plot_points = this->nplot_points(nplot);
 for (unsigned iplot=0;iplot<num_plot_points;iplot++)
  {
   
   // Get local coordinates of plot point
   this->get_s_plot(iplot,nplot,s);
   //Rotate the local coordinates
   this->rotate_local_coordinates(s);
   //Print the output
   for(unsigned i=0;i<3;i++) 
    {
     outfile << this->interpolated_x(s,i) << " ";
    }
   outfile << this->interpolated_u_poisson(s) << std::endl;   
   
  }
 
 // Write tecplot footer (e.g. FE connectivity lists)
 this->write_tecplot_zone_footer(outfile,nplot);
 
}

References i, and s.

output_fct() [1/2]

template<class ELEMENT >

void Rotateable< ELEMENT >::output_fct ( std::ostream &  outfile, const unsigned &  nplot, FiniteElement::SteadyExactSolutionFctPt  exact_soln_pt  )

inline

Output exact solution: Overloaded to produce identical output under rotation

{
 //Vector of local coordinates
 Vector<double> s(2);
 
 // Vector for coordintes
 Vector<double> x(2);
 
 // Tecplot header info
 outfile << this->tecplot_zone_string(nplot);
 
 // Exact solution Vector (here a scalar)
 Vector<double> exact_soln(1);
 
 // Loop over plot points
 unsigned num_plot_points = this->nplot_points(nplot);
 for (unsigned iplot=0;iplot<num_plot_points;iplot++)
  {
   
   // Get local coordinates of plot point
   this->get_s_plot(iplot,nplot,s);
   //Rotate the coordinates
   this->rotate_local_coordinates(s);
 
   // Get x position as Vector
   this->interpolated_x(s,x);
   
   // Get exact solution at this point
   (*exact_soln_pt)(x,exact_soln);
   
   //Output x,y,...,u_exact
   for(unsigned i=0;i<2;i++)
    {
     outfile << x[i] << " ";
    }
   outfile << exact_soln[0] << std::endl;  
  }
 
 // Write tecplot footer (e.g. FE connectivity lists)
 this->write_tecplot_zone_footer(outfile,nplot);
}

References ProblemParameters::exact_soln(), i, s, and plotDoE::x.

output_fct() [2/2]

template<class ELEMENT >

void Rotateable< ELEMENT >::output_fct ( std::ostream &  outfile, const unsigned &  nplot, FiniteElement::SteadyExactSolutionFctPt  exact_soln_pt  )

inline

Output exact solution: Overloaded to produce identical output under rotation

{
 //Vector of local coordinates
 Vector<double> s(3);
 
 // Vector for coordintes
 Vector<double> x(3);
 
 // Tecplot header info
 outfile << this->tecplot_zone_string(nplot);
 
 // Exact solution Vector (here a scalar)
 Vector<double> exact_soln(1);
 
 // Loop over plot points
 unsigned num_plot_points = this->nplot_points(nplot);
 for (unsigned iplot=0;iplot<num_plot_points;iplot++)
  {
   
   // Get local coordinates of plot point
   this->get_s_plot(iplot,nplot,s);
   //Rotate the local coordinates
   this->rotate_local_coordinates(s);
   
   // Get x position as Vector
   this->interpolated_x(s,x);
   
   // Get exact solution at this point
   (*exact_soln_pt)(x,exact_soln);
   
   //Output x,y,...,u_exact
   for(unsigned i=0;i<3;i++)
    {
     outfile << x[i] << " ";
    }
   outfile << exact_soln[0] << std::endl;  
  }
 
 // Write tecplot footer (e.g. FE connectivity lists)
 this->write_tecplot_zone_footer(outfile,nplot);
}

References ProblemParameters::exact_soln(), i, s, and plotDoE::x.

rotate() [1/2]

template<class ELEMENT >

void Rotateable< ELEMENT >::rotate ( const unsigned &  angle )

inline

Rotate the element by a given angle: 0 (0), 1(90 degrees), 2(180 degrees), 3 (270 degrees)

  {
   //Get the nodes and make a copy
   unsigned n_node = this->nnode();
   Vector<Node*> elemental_nodes_pt(n_node);
   for(unsigned n=0;n<n_node;n++)
   {
    elemental_nodes_pt[n] = this->node_pt(n);
   }
   
   //We now merely permute the nodes
   unsigned n_p = this->nnode_1d();
   //The permutation depends on the angle
   switch(angle)
    {
     //No permutation
    case 0:
     Rotated = 0;
     break;
     
     //Rotation by 90 degrees (i and j are swapped and i is reversed)
    case 1:
     Rotated = 1;
     for(unsigned i=0;i<n_p;i++)
      {
       for(unsigned j=0;j<n_p;j++)
        {
         this->node_pt(i + j*n_p)
          = elemental_nodes_pt[j + n_p*(n_p-1-i)];
        }
      }
     break;
 
     //Rotation by 180 degrees (i and j are reversed)
    case 2:
     Rotated = 2;
     for(unsigned i=0;i<n_p;i++)
      {
       for(unsigned j=0;j<n_p;j++)
        {
         this->node_pt(i + j*n_p)
          = elemental_nodes_pt[(n_p-1-i) + n_p*(n_p-1-j)];
        }
      }
     break;
 
     //Rotation by 270 degrees (i and j are swapped and new j is reversed)
    case 3:
     Rotated = 3;
     for(unsigned i=0;i<n_p;i++)
      {
       for(unsigned j=0;j<n_p;j++)
        {
         this->node_pt(i + j*n_p)
          = elemental_nodes_pt[(n_p-1-j) + n_p*i];
        }
      }
     break;
 
    default:
     Rotated = 0;
    }
  }

References Jeffery_Solution::angle(), i, j, and n.

rotate() [2/2]

template<class ELEMENT >

void Rotateable< ELEMENT >::rotate ( const unsigned &  angle )

inline

Rotate the element by a given angle: 0 (0), 1(90 degrees), 2(180 degrees), 3 (270 degrees)

  {
   Rotated = angle;
   //Get the nodes and make a copy
   unsigned n_node = this->nnode();
   Vector<Node*> elemental_nodes_pt(n_node);
   for(unsigned n=0;n<n_node;n++)
   {
    elemental_nodes_pt[n] = this->node_pt(n);
   }
 
   //Face rotation four possibilities
   unsigned face_rot = angle%4;
   
   //We now merely permute the nodes
   unsigned n_p = this->nnode_1d();
   //The permutation depends on the angle
   switch(face_rot)
    {
     //FIRST WE JUST ROTATE ABOUT THE Z-AXIS
     //No permutation
    case 0:
     break;
     
     //Rotation by 90 degrees (i and j are swapped and i is reversed)
    case 1:
     for(unsigned i=0;i<n_p;i++)
      {
       for(unsigned j=0;j<n_p;j++)
        {
         for(unsigned k=0;k<n_p;k++)
          {
           this->node_pt(i + j*n_p + k*n_p*n_p)
            = elemental_nodes_pt[j + n_p*(n_p-1-i) + k*n_p*n_p];
          }
        }
      }
     break;
 
     //Rotation by 180 degrees (i and j are reversed)
    case 2:
     for(unsigned i=0;i<n_p;i++)
      {
       for(unsigned j=0;j<n_p;j++)
        {
         for(unsigned k=0;k<n_p;k++)
          {
           this->node_pt(i + j*n_p + k*n_p*n_p)
            = elemental_nodes_pt[(n_p-1-i) + n_p*(n_p-1-j) + k*n_p*n_p];
          }
        }
      }
     break;
 
     //Rotation by 270 degrees (i and j are swapped and  j is reversed)
    case 3:
     for(unsigned i=0;i<n_p;i++)
      {
       for(unsigned j=0;j<n_p;j++)
        {
         for(unsigned k=0;k<n_p;k++)
          {
           this->node_pt(i + j*n_p + k*n_p*n_p)
            = elemental_nodes_pt[(n_p-1-j) + n_p*i + k*n_p*n_p];
          }
        }
      }
     break;
    }
 
   //Now get the nodes again, after the first rotation
   for(unsigned n=0;n<n_node;n++)
    {
     elemental_nodes_pt[n] = this->node_pt(n);
    }
 
   //We now perform the second rotation to move the face into position
   unsigned body_rot = angle/4;
   switch(body_rot)
    {
     //No permutation
    case 0:
     break;
 
     //ROTATE ABOUT X-AXIS
     //Rotation by 90 degrees (k and j are swapped and k is reversed)
    case 1:
     for(unsigned i=0;i<n_p;i++)
      {
       for(unsigned j=0;j<n_p;j++)
        {
         for(unsigned k=0;k<n_p;k++)
          {
           this->node_pt(i + j*n_p + k*n_p*n_p)
            = elemental_nodes_pt[i + n_p*(n_p-1-k) + j*n_p*n_p];
          }
        }
      }
     break;
 
     //Rotation by 180 degrees (k and j are reversed)
    case 2:
     for(unsigned i=0;i<n_p;i++)
      {
       for(unsigned j=0;j<n_p;j++)
        {
         for(unsigned k=0;k<n_p;k++)
          {
           this->node_pt(i + j*n_p + k*n_p*n_p)
            = elemental_nodes_pt[i + n_p*(n_p-1-j) + (n_p-1-k)*n_p*n_p];
          }
        }
      }
     break;
 
     //Rotation by 270 degrees (k and j are swapped and j is reversed)
    case 3:
     for(unsigned i=0;i<n_p;i++)
      {
       for(unsigned j=0;j<n_p;j++)
        {
         for(unsigned k=0;k<n_p;k++)
          {
           this->node_pt(i + j*n_p + k*n_p*n_p)
            = elemental_nodes_pt[i + n_p*k + (n_p-1-j)*n_p*n_p];
          }
        }
      }
     break;
 
     //ROTATE ABOUT Y-AXIS
     //Rotation by 90 degrees (i and k are swapped and i is reversed)
    case 4:
     for(unsigned i=0;i<n_p;i++)
      {
       for(unsigned j=0;j<n_p;j++)
        {
         for(unsigned k=0;k<n_p;k++)
          {
           this->node_pt(i + j*n_p + k*n_p*n_p)
            = elemental_nodes_pt[k + n_p*j + (n_p-1-i)*n_p*n_p];
          }
        }
      }
     break;
     
     //Rotation by 270 degrees (i and k are swapped and k is reversed)
    case 5:
     for(unsigned i=0;i<n_p;i++)
      {
       for(unsigned j=0;j<n_p;j++)
        {
         for(unsigned k=0;k<n_p;k++)
          {
           this->node_pt(i + j*n_p + k*n_p*n_p)
            = elemental_nodes_pt[(n_p-1-k) + n_p*j + i*n_p*n_p];
          }
        }
      }
     break;
    }  
  }

References Jeffery_Solution::angle(), i, j, k, and n.

rotate_local_coordinates() [1/2]

template<class ELEMENT >

void Rotateable< ELEMENT >::rotate_local_coordinates ( Vector< double > &  s )

inline

Rotate the local coordinates so that that output is will be consistent, irrespective of the rotation of the element

  {
   //Rotated coordinates
   Vector<double> s_rot(2);
   //Do the four different cases
   switch(Rotated)
    {
    case 0:
     s_rot[0] = s[0]; s_rot[1] = s[1];
     break;
     
    case 1:
     s_rot[0] = -s[1]; s_rot[1] = s[0];
     break;
 
    case 2:
     s_rot[0] = -s[0]; s_rot[1] = -s[1];
     break;
 
    case 3:
     s_rot[0] = s[1]; s_rot[1] = -s[0];
     break;
    }
   
   //Now do the rotation
   s[0] = s_rot[0]; s[1] = s_rot[1];
  }

References s.

rotate_local_coordinates() [2/2]

template<class ELEMENT >

void Rotateable< ELEMENT >::rotate_local_coordinates ( Vector< double > &  s )

inline

Rotate the local coordinates so that that output is will be consistent, irrespective of the rotation of the element

  {
   //Now rotate about the face
   Vector<double> s_rot(3);
   unsigned face_rot = Rotated%4;
   switch(face_rot)
    {
    case 0:
     s_rot[0] = s[0]; s_rot[1] = s[1]; s_rot[2] = s[2];
     break;
     
    case 1:
     s_rot[0] = -s[1]; s_rot[1] = s[0]; s_rot[2] = s[2];
     break;
 
    case 2:
     s_rot[0] = -s[0]; s_rot[1] = -s[1]; s_rot[2] = s[2];
     break;
 
    case 3:
     s_rot[0] = s[1]; s_rot[1] = -s[0]; s_rot[2] = s[2];
     break;
    }
 
   //Rotate the face into position
   unsigned body_rot = Rotated/4;
   Vector<double> s_rot2(3);
   switch(body_rot)
    {
    case 0:
     s_rot2[0] = s_rot[0]; s_rot2[1] = s_rot[1]; s_rot2[2] = s_rot[2];
     break;
     
    case 1:
     s_rot2[0] = s_rot[0]; s_rot2[1] = s_rot[2]; s_rot2[2] = -s_rot[1];
     break;
 
    case 2:
     s_rot2[0] = s_rot[0]; s_rot2[1] = -s_rot[1]; s_rot2[2] = -s_rot[2];
     break;
     
    case 3:
     s_rot2[0] = s_rot[0]; s_rot2[1] = -s_rot[2]; s_rot2[2] = s_rot[1];
     break;
 
    case 4:
     s_rot2[0] = -s_rot[2]; s_rot2[1] = s_rot[1]; s_rot2[2] = s_rot[0];
     break;
 
    case 5:
     s_rot2[0] = s_rot[2]; s_rot2[1] = s_rot[1]; s_rot2[2] = -s_rot[0];
     break;
    }
 
   //Set the input to the rotated coordinate
   s[0] = s_rot2[0]; s[1] = s_rot2[1]; s[2] = s_rot2[2];
  }

References s.

Member Data Documentation

Rotated

template<class ELEMENT >

unsigned Rotateable< ELEMENT >::Rotated

private

Integer to store the rotation angle.

---

The documentation for this class was generated from the following files:

• tree_2d.cc
• tree_3d.cc