oomph::Rotateable< ELEMENT > Class Template Reference

Inheritance diagram for oomph::Rotateable< ELEMENT >:

Public Member Functions
	Rotateable ()
	Constructor, initialise rotation to zero (default) More...
void	further_build ()
void	rotate (const unsigned &angle)
	Rotate the element. More...
void	rotate_local_coordinates (Vector< double > &s)

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

Detailed Description

template<class ELEMENT>
class oomph::Rotateable< ELEMENT >

Class to overload an refineable QElement<3,...> so that it can be rotated about its centre.

Constructor & Destructor Documentation

Rotateable()

template<class ELEMENT >

oomph::Rotateable< ELEMENT >::Rotateable ( )

inline

Constructor, initialise rotation to zero (default)

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

Member Function Documentation

further_build()

template<class ELEMENT >

void oomph::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;
  }

rotate()

template<class ELEMENT >

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

inline

Rotate the element.

  {
   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()

template<class ELEMENT >

void oomph::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:

• octree_test.cc
• tree_3d.cc