#include <periodic_orbit_handler.h>

Inheritance diagram for oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >:

Public Member Functions
	PeriodicOrbitAssemblyHandler (Problem *const &problem_pt, const unsigned &n_element_in_period, const DenseMatrix< double > &initial_guess, const double &omega)
	Constructor, initialises values and constructs mesh of elements. More...

void	set_previous_dofs_to_current_dofs ()
	Update the previous dofs. More...

unsigned	ndof (GeneralisedElement *const &elem_pt)
	Return the number of degrees of freedom in the element elem_pt. More...

unsigned long	eqn_number (GeneralisedElement *const &elem_pt, const unsigned &ieqn_local)

void	get_residuals (GeneralisedElement *const &elem_pt, Vector< double > &residuals)
	Return the contribution to the residuals of the element elem_pt. More...

void	get_dofs_for_element (GeneralisedElement *const elem_pt, Vector< double > &dofs)

void	get_previous_dofs_for_element (GeneralisedElement *const elem_pt, Vector< double > &dofs)

void	set_dofs_for_element (GeneralisedElement *const elem_pt, Vector< double > const &dofs)

void	get_jacobian (GeneralisedElement *const &elem_pt, Vector< double > &residuals, DenseMatrix< double > &jacobian)

void	orbit_output (std::ostream &outfile, const unsigned &n_plot)
	Return the contribution to the residuals of the element elem_pt. More...

void	discrete_times (Vector< double > &t)
	Tell me the times at which you want the solution. More...

void	adapt_temporal_mesh ()
	Adapt the time mesh. More...

	~PeriodicOrbitAssemblyHandler ()
	Destructor, destroy the time mesh. More...

Public Member Functions inherited from oomph::PeriodicOrbitAssemblyHandlerBase
	PeriodicOrbitAssemblyHandlerBase ()

Public Member Functions inherited from oomph::AssemblyHandler
	AssemblyHandler ()
	Empty constructor. More...

virtual void	dof_vector (GeneralisedElement *const &elem_pt, const unsigned &t, Vector< double > &dof)
	Return vector of dofs at time level t in the element elem_pt. More...

virtual void	dof_pt_vector (GeneralisedElement const &elem_pt, Vector< double > &dof_pt)
	Return vector of pointers to dofs in the element elem_pt. More...

virtual double &	local_problem_dof (Problem *const &problem_pt, const unsigned &t, const unsigned &i)

virtual void	get_all_vectors_and_matrices (GeneralisedElement *const &elem_pt, Vector< Vector< double >> &vec, Vector< DenseMatrix< double >> &matrix)

virtual void	get_dresiduals_dparameter (GeneralisedElement const &elem_pt, double const &parameter_pt, Vector< double > &dres_dparam)

virtual void	get_djacobian_dparameter (GeneralisedElement const &elem_pt, double const &parameter_pt, Vector< double > &dres_dparam, DenseMatrix< double > &djac_dparam)

virtual void	get_hessian_vector_products (GeneralisedElement *const &elem_pt, Vector< double > const &Y, DenseMatrix< double > const &C, DenseMatrix< double > &product)

virtual int	bifurcation_type () const

virtual double *	bifurcation_parameter_pt () const

virtual void	get_eigenfunction (Vector< DoubleVector > &eigenfunction)

virtual void	get_inner_products (GeneralisedElement *const &elem_pt, Vector< std::pair< unsigned, unsigned >> const &history_index, Vector< double > &inner_product)

virtual void	get_inner_product_vectors (GeneralisedElement *const &elem_pt, Vector< unsigned > const &history_index, Vector< Vector< double >> &inner_product_vector)

virtual	~AssemblyHandler ()
	Empty virtual destructor. More...

Private Attributes
PeriodicOrbitTimeDiscretisation *	Time_stepper_pt
	Pointer to the timestepper. More...

Problem *	Problem_pt
	Pointer to the problem. More...

PeriodicOrbitTemporalMesh< SpectralPeriodicOrbitElement< NNODE_1D > > *	Time_mesh_pt
	Storage for mesh of temporal elements. More...

Mesh *	Basic_time_mesh_pt
	Storage for the mesh of temporal elements with a simple mesh pointer. More...

Vector< double >	Previous_dofs
	Storage for the previous solution. More...

unsigned	Ndof
	Store number of degrees of freedom in the original problem. More...

unsigned	N_element_in_period
	Storage for number of elements in the period. More...

unsigned	N_tstorage
	Storage for the number of unknown time values. More...

double	Omega
	Storage for the frequency of the orbit (scaled by 2pi) More...

Detailed Description

template<unsigned NNODE_1D>
class oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >

A class that is used to assemble and solve the augmented system of equations associated with calculating periodic orbits directly

Constructor & Destructor Documentation

◆ PeriodicOrbitAssemblyHandler()

template<unsigned NNODE_1D>

oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::PeriodicOrbitAssemblyHandler	(	Problem *const &	problem_pt,
		const unsigned &	n_element_in_period,
		const DenseMatrix< double > &	initial_guess,
		const double &	omega
	)

inline

Constructor, initialises values and constructs mesh of elements.

       : Problem_pt(problem_pt),
         N_element_in_period(n_element_in_period),
         Omega(omega / (2.0 * MathematicalConstants::Pi))
     {
       // Store the current number of degrees of freedom
       Ndof = problem_pt->ndof();
  
       // Create the appropriate mesh of "1D" time elements depending on
       // the specified spectral order
       // The time domain runs from zero to one
       Time_mesh_pt =
         new PeriodicOrbitTemporalMesh<SpectralPeriodicOrbitElement<NNODE_1D>>(
           n_element_in_period);
  
       Basic_time_mesh_pt = Time_mesh_pt;
  
       // Set the error estimator
       Time_mesh_pt->spatial_error_estimator_pt() = new Z2ErrorEstimator;
       Time_mesh_pt->max_permitted_error() = 1.0e-2;
       Time_mesh_pt->min_permitted_error() = 1.0e-5;
       Time_mesh_pt->max_refinement_level() = 10;
  
       // Now we need to number the mesh
       // Dummy dof pointer
       Vector<double*> dummy_dof_pt;
       Time_mesh_pt->assign_global_eqn_numbers(dummy_dof_pt);
       // Assign the local equation numbers
       Time_mesh_pt->assign_local_eqn_numbers(false);
  
       // Find the number of temporal degrees of freedom
       N_tstorage = dummy_dof_pt.size();
  
       // Now we need to do something clever to setup the time storage schemes
       // and the initial values (don't quite know what that is yet)
  
       // Create the "fake" timestepper
       Time_stepper_pt = new PeriodicOrbitTimeDiscretisation(N_tstorage);
       // Loop over the temporal elements and set the pointers
       for (unsigned e = 0; e < n_element_in_period; e++)
       {
         SpectralPeriodicOrbitElement<NNODE_1D>* el_pt =
           dynamic_cast<SpectralPeriodicOrbitElement<NNODE_1D>*>(
             Time_mesh_pt->element_pt(e));
  
         // Set the time and the timestepper
         el_pt->time_pt() = problem_pt->time_pt();
         el_pt->time_stepper_pt() = Time_stepper_pt;
  
         // Set the number of temporal degrees of freedom
         el_pt->set_ntstorage(N_tstorage);
         // Set the frequency
         el_pt->omega_pt() = &Omega;
       }
  
       // We now need to do something much more drastic which is to loop over all
       // our the data in the problem and change the timestepper, which is going
       // to be a real pain when I start to worry about halo nodes, etc.
  
       // Will need to use the appropriate mesh-level functions that have
       // not been written yet ..
  
       // Let's just break if there are submeshes
       if (problem_pt->nsub_mesh() > 0)
       {
         throw OomphLibError(
           "PeriodicOrbitHandler can't cope with submeshes yet",
           OOMPH_CURRENT_FUNCTION,
           OOMPH_EXCEPTION_LOCATION);
       }
  
       // OK now we have only one mesh
       unsigned n_node = problem_pt->mesh_pt()->nnode();
       for (unsigned n = 0; n < n_node; n++)
       {
         Node* const nod_pt = problem_pt->mesh_pt()->node_pt(n);
         nod_pt->set_time_stepper(Time_stepper_pt, false);
         // If the unknowns are pinned then copy the value to all values
         unsigned n_value = nod_pt->nvalue();
         for (unsigned i = 0; i < n_value; i++)
         {
           if (nod_pt->is_pinned(i))
           {
             const unsigned n_tstorage = nod_pt->ntstorage();
             const double value = nod_pt->value(i);
             for (unsigned t = 1; t < n_tstorage; t++)
             {
               nod_pt->set_value(t, i, value);
             }
           }
         }
       }
  
       unsigned n_element = problem_pt->mesh_pt()->nelement();
       for (unsigned e = 0; e < n_element; e++)
       {
         unsigned n_internal =
           problem_pt->mesh_pt()->element_pt(e)->ninternal_data();
         for (unsigned i = 0; i < n_internal; i++)
         {
           // Cache the internal data
           Data* const data_pt =
             problem_pt->mesh_pt()->element_pt(e)->internal_data_pt(i);
           // and set the timestepper
           data_pt->set_time_stepper(Time_stepper_pt, false);
  
           // If the unknowns are pinned then copy the value to all values
           unsigned n_value = data_pt->nvalue();
           for (unsigned j = 0; j < n_value; j++)
           {
             if (data_pt->is_pinned(j))
             {
               const unsigned n_tstorage = data_pt->ntstorage();
               const double value = data_pt->value(j);
               for (unsigned t = 1; t < n_tstorage; t++)
               {
                 data_pt->set_value(t, j, value);
               }
             }
           }
         }
       }
  
       // Need to reassign equation numbers so that the DOF pointer, points to
       // the newly allocated storage
       oomph_info << "Re-allocated " << problem_pt->assign_eqn_numbers()
                  << " equation numbers\n";
  
       // Now's let's add all the unknowns to the problem
       problem_pt->Dof_pt.resize(Ndof * N_tstorage + 1);
       // This is reasonably straight forward using pointer arithmetic
       // but this does rely on knowing how the data is stored in the
       // Nodes which is a little nasty
       for (unsigned i = 0; i < N_tstorage; i++)
       {
         unsigned offset = Ndof * i;
         for (unsigned n = 0; n < Ndof; n++)
         {
           problem_pt->Dof_pt[offset + n] = problem_pt->Dof_pt[n] + i;
         }
       }
  
       // Add the frequency of the orbit to the unknowns
       problem_pt->Dof_pt[Ndof * N_tstorage] = &Omega;
  
       // Rebuild everything
       problem_pt->Dof_distribution_pt->build(
         problem_pt->communicator_pt(), Ndof * N_tstorage + 1, true);
  
  
       // Set initial condition of constant-ness plus wobble
       for (unsigned i = 0; i < N_tstorage; i++)
       {
         unsigned offset = Ndof * i;
         for (unsigned n = 0; n < Ndof; n++)
         {
           problem_pt->dof(offset + n) =
             initial_guess(i, n); // problem_pt->dof(n);
         }
       }
  
       // Set the initial unkowns to be the original problem
       Previous_dofs.resize(Ndof * N_tstorage + 1, 0.0);
       this->set_previous_dofs_to_current_dofs();
  
       // Now check everything is OK ... it seems to be
       // std::cout << problem_pt->ndof() << "\n";
       // Let's check it
       // for(unsigned i=0;i<problem_pt->ndof();i++)
       // {
       //  std::cout << i << " " << problem_pt->dof(i) << "\n";
       //}
     }

◆ ~PeriodicOrbitAssemblyHandler()

template<unsigned NNODE_1D>

oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::~PeriodicOrbitAssemblyHandler ( )

inline

Destructor, destroy the time mesh.

     {
       delete Time_mesh_pt;
     }

References oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::Time_mesh_pt.

Member Function Documentation

◆ adapt_temporal_mesh()

template<unsigned NNODE_1D>

void oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::adapt_temporal_mesh ( )

inline

Adapt the time mesh.

     {
       // First job is to compute some sort of error measure
       // Then we can decide how to refine this is probably best handled
       // separately for now
  
       // The current plan is to copy all (locally held in the case of
       // distributed problem) spatial degrees of freedom into the dummy
       // storage of the time mesh
  
       // Probably should kick this down to the mesh level...
  
       // OK, let's do it, count up all values
       unsigned total_n_value = 0;
  
       // Firstly the global data in the mesh
       unsigned n_global_data = Problem_pt->nglobal_data();
       for (unsigned i = 0; i < n_global_data; i++)
       {
         total_n_value += Problem_pt->global_data_pt(i)->nvalue();
       }
  
       // Now the nodal data
       unsigned n_node = Problem_pt->mesh_pt()->nnode();
       for (unsigned n = 0; n < n_node; n++)
       {
         total_n_value += Problem_pt->mesh_pt()->node_pt(n)->nvalue();
         SolidNode* solid_nod_pt =
           dynamic_cast<SolidNode*>(Problem_pt->mesh_pt()->node_pt(n));
         if (solid_nod_pt != 0)
         {
           total_n_value += solid_nod_pt->variable_position_pt()->nvalue();
         }
       }
  
       // Now just do the internal data
       unsigned n_space_element = Problem_pt->mesh_pt()->nelement();
       for (unsigned e = 0; e < n_space_element; e++)
       {
         const unsigned n_internal_data =
           Problem_pt->mesh_pt()->element_pt(e)->ninternal_data();
         for (unsigned i = 0; i < n_internal_data; i++)
         {
           total_n_value +=
             Problem_pt->mesh_pt()->element_pt(e)->internal_data_pt(i)->nvalue();
         }
       }
  
       // Now in theory I know the total number of values in the problem
       // So I can create another Fake timestepper
       TimeStepper* fake_space_time_stepper_pt =
         new PeriodicOrbitTimeDiscretisation(total_n_value);
  
       // Now apply this time stepper to all time nodes
       unsigned n_time_node = Time_mesh_pt->nnode();
       for (unsigned t = 0; t < n_time_node; t++) // Do  include the periodic one
       {
         Time_mesh_pt->node_pt(t)->set_time_stepper(fake_space_time_stepper_pt,
                                                    false);
       }
  
       // Now I "just" copy the values into the new storage
       unsigned count = 0;
       for (unsigned i = 0; i < n_global_data; i++)
       {
         Data* const glob_data_pt = Problem_pt->global_data_pt(i);
         const unsigned n_value = glob_data_pt->nvalue();
         for (unsigned j = 0; j < n_value; j++)
         {
           for (unsigned t = 0; t < N_tstorage; t++)
           {
             // Some heavy assumptions here about the time mesh, but that's OK
             // because I know exactly how it's laid out
             Time_mesh_pt->node_pt(t)->set_value(
               count, 0, glob_data_pt->value(t, j));
           }
           ++count;
         }
       }
  
       // Now the nodal data
       for (unsigned n = 0; n < n_node; n++)
       {
         Node* const nod_pt = Problem_pt->mesh_pt()->node_pt(n);
         const unsigned n_value = nod_pt->nvalue();
         for (unsigned i = 0; i < n_value; i++)
         {
           for (unsigned t = 0; t < N_tstorage; t++)
           {
             Time_mesh_pt->node_pt(t)->set_value(count, 0, nod_pt->value(t, i));
           }
           ++count;
         }
  
         // Now deal with the solid node data
         SolidNode* solid_nod_pt = dynamic_cast<SolidNode*>(nod_pt);
         if (solid_nod_pt != 0)
         {
           const unsigned n_solid_value =
             solid_nod_pt->variable_position_pt()->nvalue();
           for (unsigned i = 0; i < n_solid_value; i++)
           {
             for (unsigned t = 0; t < N_tstorage; t++)
             {
               Time_mesh_pt->node_pt(t)->set_value(
                 count, 0, solid_nod_pt->variable_position_pt()->value(t, i));
             }
             ++count;
           }
         }
       }
  
       // Now just do the internal data
       for (unsigned e = 0; e < n_space_element; e++)
       {
         const unsigned n_internal =
           Problem_pt->mesh_pt()->element_pt(e)->ninternal_data();
         for (unsigned i = 0; i < n_internal; i++)
         {
           Data* const internal_dat_pt =
             Problem_pt->mesh_pt()->element_pt(e)->internal_data_pt(i);
  
           const unsigned n_value = internal_dat_pt->nvalue();
           for (unsigned j = 0; j < n_value; j++)
           {
             for (unsigned t = 0; t < N_tstorage; t++)
             {
               Time_mesh_pt->node_pt(t)->set_value(
                 count, 0, internal_dat_pt->value(t, j));
             }
             ++count;
           }
         }
       }
  
  
       // Think it's done but let's check
       /*{
        std::ofstream munge("data_remunge.dat");
        const unsigned n_time_element = Time_mesh_pt->nelement();
        for(unsigned e=0;e<n_time_element;e++)
         {
          const unsigned n_node = Time_mesh_pt->nnode();
          for(unsigned n=0;n<n_node;n++)
           {
            Node* const nod_pt = Time_mesh_pt->node_pt(n);
            munge << nod_pt->x(0) << " ";
            const unsigned n_space_storage = nod_pt->ntstorage();
            for(unsigned t=0;t<n_space_storage;t++)
             {
              munge << nod_pt->value(t,0) << " ";
             }
            munge << std::endl;
           }
         }
        munge.close();
        }*/
  
       // Ok get the elemental errors
       const unsigned n_time_element = Time_mesh_pt->nelement();
       Vector<double> elemental_error(n_time_element);
       Time_mesh_pt->spatial_error_estimator_pt()->get_element_errors(
         Problem_pt->communicator_pt(), Basic_time_mesh_pt, elemental_error);
  
       // Let's dump it
       for (unsigned e = 0; e < n_time_element; e++)
       {
         oomph_info << e << " " << elemental_error[e] << "\n";
       }
  
       // Now adapt the mesh
       Time_mesh_pt->adapt(Problem_pt->communicator_pt(), elemental_error);
  
       // I seem to have remunged the data,
       // Now let's pretend that we have done the the error adaptation
       // Time_mesh_pt->refine_uniformly();
  
       // Let's just refine the central elements twice
       // Vector<unsigned> refine_elements;
       // refine_elements.push_back(0);
       // refine_elements.push_back(9);
       // Time_mesh_pt->refine_selected_elements(refine_elements);
       // refine_elements.clear();
       // refine_elements.push_back(0);
       // refine_elements.push_back(1);
       // refine_elements.push_back(10);
       // refine_elements.push_back(11);
       // Time_mesh_pt->refine_selected_elements(refine_elements);
  
       /* std::ofstream munge("data_refine.dat");
       const unsigned n_time_element = Time_mesh_pt->nelement();
       for(unsigned e=0;e<n_time_element;e++)
        {
         const unsigned n_node = Time_mesh_pt->nnode();
         for(unsigned n=0;n<n_node;n++)
          {
           Node* const nod_pt = Time_mesh_pt->node_pt(n);
           munge << nod_pt->x(0) << " ";
           const unsigned n_space_storage = nod_pt->ntstorage();
           for(unsigned t=0;t<n_space_storage;t++)
            {
             munge << nod_pt->value(t,0) << " ";
            }
           munge << std::endl;
          }
        }
        munge.close();*/
  
       // Now we need to put the refined data back into the problem
  
       // Now we need to number the mesh
       // Dummy dof pointer
       Vector<double*> dummy_dof_pt;
       Time_mesh_pt->assign_global_eqn_numbers(dummy_dof_pt);
       // Assign the local equation numbers
       Time_mesh_pt->assign_local_eqn_numbers(false);
  
       // Find the number of temporal degrees of freedom
       N_tstorage = dummy_dof_pt.size();
       // and new number of elements
       N_element_in_period = Time_mesh_pt->nelement();
  
       // Create the new "fake" timestepper
       PeriodicOrbitTimeDiscretisation* periodic_time_stepper_pt =
         new PeriodicOrbitTimeDiscretisation(N_tstorage);
  
       // Loop over the temporal elements and set the pointers
       for (unsigned e = 0; e < N_element_in_period; e++)
       {
         SpectralPeriodicOrbitElement<NNODE_1D>* el_pt =
           dynamic_cast<SpectralPeriodicOrbitElement<NNODE_1D>*>(
             Time_mesh_pt->element_pt(e));
  
         // Set the time and the timestepper
         el_pt->time_pt() = Problem_pt->time_pt();
         el_pt->time_stepper_pt() = periodic_time_stepper_pt;
  
         // Set the number of temporal degrees of freedom
         el_pt->set_ntstorage(N_tstorage);
         // Set the frequency
         el_pt->omega_pt() = &Omega;
       }
  
       // We now need to do something much more drastic which is to loop over all
       // our the data in the problem and change the timestepper, which is going
       // to be a real pain when I start to worry about halo nodes, etc.
  
       // Will need to use the appropriate mesh-level functions that have
       // not been written yet ..
  
       // Let's just break if there are submeshes
       if (Problem_pt->nsub_mesh() > 0)
       {
         throw OomphLibError(
           "PeriodicOrbitHandler can't cope with submeshes yet",
           OOMPH_CURRENT_FUNCTION,
           OOMPH_EXCEPTION_LOCATION);
       }
  
       // OK now we have only one mesh
       for (unsigned n = 0; n < n_node; n++)
       {
         Node* const nod_pt = Problem_pt->mesh_pt()->node_pt(n);
         nod_pt->set_time_stepper(periodic_time_stepper_pt, false);
       }
  
       for (unsigned e = 0; e < n_space_element; e++)
       {
         unsigned n_internal =
           Problem_pt->mesh_pt()->element_pt(e)->ninternal_data();
         for (unsigned i = 0; i < n_internal; i++)
         {
           // Cache the internal data
           Data* const data_pt =
             Problem_pt->mesh_pt()->element_pt(e)->internal_data_pt(i);
           // and set the timestepper
           data_pt->set_time_stepper(periodic_time_stepper_pt, false);
         }
       }
  
       // Now I can delete the old timestepper and switch
       delete Time_stepper_pt;
       Time_stepper_pt = periodic_time_stepper_pt;
  
       // Need to reassign equation numbers so that the DOF pointer, points to
       // the newly allocated storage
       oomph_info << "Re-allocated " << Problem_pt->assign_eqn_numbers()
                  << " equation numbers\n";
  
       // Now's let's add all the unknowns to the problem
       Problem_pt->Dof_pt.resize(Ndof * N_tstorage + 1);
       // This is reasonably straight forward using pointer arithmetic
       // but this does rely on knowing how the data is stored in the
       // Nodes which is a little nasty
       for (unsigned i = 0; i < N_tstorage; i++)
       {
         unsigned offset = Ndof * i;
         for (unsigned n = 0; n < Ndof; n++)
         {
           Problem_pt->Dof_pt[offset + n] = Problem_pt->Dof_pt[n] + i;
         }
       }
  
       // Add the frequency of the orbit to the unknowns
       Problem_pt->Dof_pt[Ndof * N_tstorage] = &Omega;
  
       // Rebuild everything
       Problem_pt->Dof_distribution_pt->build(
         Problem_pt->communicator_pt(), Ndof * N_tstorage + 1, true);
  
  
       // Now finally transfer the solution accross
  
       // Now I "just" copy the values into the new storage
       count = 0;
       for (unsigned i = 0; i < n_global_data; i++)
       {
         Data* const glob_data_pt = Problem_pt->global_data_pt(i);
         const unsigned n_value = glob_data_pt->nvalue();
         for (unsigned j = 0; j < n_value; j++)
         {
           for (unsigned t = 0; t < N_tstorage; t++)
           {
             // Some heavy assumptions here about the time mesh, but that's OK
             // because I know exactly how it's laid out
             glob_data_pt->set_value(
               t, j, Time_mesh_pt->node_pt(t)->value(count, 0));
           }
           ++count;
         }
       }
  
       // Now the nodal data
       for (unsigned n = 0; n < n_node; n++)
       {
         Node* const nod_pt = Problem_pt->mesh_pt()->node_pt(n);
         const unsigned n_value = nod_pt->nvalue();
         for (unsigned i = 0; i < n_value; i++)
         {
           for (unsigned t = 0; t < N_tstorage; t++)
           {
             nod_pt->set_value(t, i, Time_mesh_pt->node_pt(t)->value(count, 0));
           }
           ++count;
         }
  
         // Now deal with the solid node data
         SolidNode* solid_nod_pt = dynamic_cast<SolidNode*>(nod_pt);
         if (solid_nod_pt != 0)
         {
           const unsigned n_solid_value =
             solid_nod_pt->variable_position_pt()->nvalue();
           for (unsigned i = 0; i < n_solid_value; i++)
           {
             for (unsigned t = 0; t < N_tstorage; t++)
             {
               solid_nod_pt->variable_position_pt()->set_value(
                 t, i, Time_mesh_pt->node_pt(t)->value(count, 0));
             }
             ++count;
           }
         }
       }
  
       // Now just do the internal data
       for (unsigned e = 0; e < n_space_element; e++)
       {
         const unsigned n_internal =
           Problem_pt->mesh_pt()->element_pt(e)->ninternal_data();
         for (unsigned i = 0; i < n_internal; i++)
         {
           Data* const internal_dat_pt =
             Problem_pt->mesh_pt()->element_pt(e)->internal_data_pt(i);
  
           const unsigned n_value = internal_dat_pt->nvalue();
           for (unsigned j = 0; j < n_value; j++)
           {
             for (unsigned t = 0; t < N_tstorage; t++)
             {
               internal_dat_pt->set_value(
                 t, j, Time_mesh_pt->node_pt(t)->value(count, 0));
             }
             ++count;
           }
         }
       }
  
  
       // Now I should be able to delete the fake time timestepper
       n_time_node = Time_mesh_pt->nnode();
       for (unsigned t = 0; t < n_time_node; t++)
       {
         Time_mesh_pt->node_pt(t)->set_time_stepper(&Mesh::Default_TimeStepper,
                                                    false);
       }
       // Delete the fake timestepper
       delete fake_space_time_stepper_pt;
  
       // Set the initial unkowns to be the original problem
       Previous_dofs.resize(Ndof * N_tstorage + 1, 0.0);
       this->set_previous_dofs_to_current_dofs();
     }

◆ discrete_times()

template<unsigned NNODE_1D>

void oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::discrete_times ( Vector< double > & t )

inline

Tell me the times at which you want the solution.

     {
       const unsigned n_node = Time_mesh_pt->nnode();
       t.resize(n_node);
       for (unsigned n = 0; n < n_node; n++)
       {
         t[n] = Time_mesh_pt->node_pt(n)->x(0);
       }
     }

References n, plotPSD::t, and oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::Time_mesh_pt.

◆ eqn_number()

template<unsigned NNODE_1D>

unsigned long oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::eqn_number	(	GeneralisedElement *const &	elem_pt,
		const unsigned &	ieqn_local
	)

inlinevirtual

Return the global equation number of the local unknown ieqn_local in elem_pt.

Reimplemented from oomph::AssemblyHandler.

     {
       // Get unaugmented number of (spatial) dofs in element
       unsigned raw_ndof = elem_pt->ndof();
       // The final variable (the period) is stored at the end
       if (ieqn_local == raw_ndof * N_tstorage)
       {
         return N_tstorage * Ndof;
       }
       // Otherwise  we need to do a little more work
       else
       {
         // Now find out the time level
         unsigned t = ieqn_local / raw_ndof;
         // and the remainder (original eqn number)
         unsigned raw_ieqn = ieqn_local % raw_ndof;
         // hence calculate the global value
         return t * Ndof + elem_pt->eqn_number(raw_ieqn);
       }
     }

References oomph::GeneralisedElement::eqn_number(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::N_tstorage, oomph::GeneralisedElement::ndof(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::Ndof, and plotPSD::t.

Referenced by oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::get_dofs_for_element(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::get_previous_dofs_for_element(), and oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::set_dofs_for_element().

◆ get_dofs_for_element()

template<unsigned NNODE_1D>

void oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::get_dofs_for_element	(	GeneralisedElement *const	elem_pt,
		Vector< double > &	dofs
	)

inlinevirtual

Implements oomph::PeriodicOrbitAssemblyHandlerBase.

     {
       // Find the number of dofs in the element
       const unsigned n_elem_dof = this->ndof(elem_pt);
       dofs.resize(n_elem_dof);
       // Now just get the dofs corresponding to the element's unknowns from the
       // problem dof
       for (unsigned i = 0; i < n_elem_dof; i++)
       {
         dofs[i] = Problem_pt->dof(this->eqn_number(elem_pt, i));
       }
     }

References oomph::Problem::dof(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::eqn_number(), i, oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::ndof(), and oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::Problem_pt.

◆ get_jacobian()

template<unsigned NNODE_1D>

void oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::get_jacobian	(	GeneralisedElement *const &	elem_pt,
		Vector< double > &	residuals,
		DenseMatrix< double > &	jacobian
	)

inlinevirtual

Calculate the elemental Jacobian matrix "d equation / d variable" for elem_pt.

Reimplemented from oomph::AssemblyHandler.

     {
       Time_mesh_pt->assemble_residuals_and_jacobian(
         this, elem_pt, residuals, jacobian);
     }

References oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::Time_mesh_pt.

◆ get_previous_dofs_for_element()

template<unsigned NNODE_1D>

void oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::get_previous_dofs_for_element	(	GeneralisedElement *const	elem_pt,
		Vector< double > &	dofs
	)

inlinevirtual

Implements oomph::PeriodicOrbitAssemblyHandlerBase.

     {
       // Find the number of dofs in the element
       const unsigned n_elem_dof = this->ndof(elem_pt);
       dofs.resize(n_elem_dof);
       // Now just get the dofs corresponding to the element's unknowns from the
       // problem dof
       for (unsigned i = 0; i < n_elem_dof; i++)
       {
         dofs[i] = Previous_dofs[this->eqn_number(elem_pt, i)];
       }
     }

References oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::eqn_number(), i, oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::ndof(), and oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::Previous_dofs.

◆ get_residuals()

template<unsigned NNODE_1D>

void oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::get_residuals	(	GeneralisedElement *const &	elem_pt,
		Vector< double > &	residuals
	)

inlinevirtual

Return the contribution to the residuals of the element elem_pt.

Reimplemented from oomph::AssemblyHandler.

     {
       Time_mesh_pt->assemble_residuals(this, elem_pt, residuals);
     }

References oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::Time_mesh_pt.

◆ ndof()

template<unsigned NNODE_1D>

unsigned oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::ndof ( GeneralisedElement *const & elem_pt )

inlinevirtual

Return the number of degrees of freedom in the element elem_pt.

Reimplemented from oomph::AssemblyHandler.

     {
       return ((elem_pt->ndof()) * N_tstorage + 1);
     }

References oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::N_tstorage, and oomph::GeneralisedElement::ndof().

Referenced by oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::get_dofs_for_element(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::get_previous_dofs_for_element(), and oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::set_dofs_for_element().

◆ orbit_output()

template<unsigned NNODE_1D>

void oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::orbit_output	(	std::ostream &	outfile,
		const unsigned &	n_plot
	)

inline

Return the contribution to the residuals of the element elem_pt.

Calculate all desired vectors and matrices provided by the element elem_pt. Return an unsigned integer to indicate whether the handler is a bifurcation tracking handler. The default is zero (not) Return a pointer to the bifurcation parameter in bifurcation tracking problems Return the eigenfunction(s) associated with the bifurcation that has been detected in bifurcation tracking problems

     {
       const unsigned n_element = Problem_pt->mesh_pt()->nelement();
       for (unsigned e = 0; e < n_element; e++)
       {
         Time_mesh_pt->orbit_output(
           Problem_pt->mesh_pt()->element_pt(e), outfile, n_plot);
       }
     }

References e(), oomph::Mesh::element_pt(), oomph::Problem::mesh_pt(), oomph::Mesh::nelement(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::Problem_pt, and oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::Time_mesh_pt.

◆ set_dofs_for_element()

template<unsigned NNODE_1D>

void oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::set_dofs_for_element	(	GeneralisedElement *const	elem_pt,
		Vector< double > const &	dofs
	)

inlinevirtual

Implements oomph::PeriodicOrbitAssemblyHandlerBase.

     {
       // Find the number of dofs in the element
       const unsigned n_elem_dof = this->ndof(elem_pt);
       // Now just get the dofs corresponding to the element's unknowns from the
       // problem dof
       for (unsigned i = 0; i < n_elem_dof; i++)
       {
         Problem_pt->dof(this->eqn_number(elem_pt, i)) = dofs[i];
       }
     }

References oomph::Problem::dof(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::eqn_number(), i, oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::ndof(), and oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::Problem_pt.

◆ set_previous_dofs_to_current_dofs()

template<unsigned NNODE_1D>

void oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::set_previous_dofs_to_current_dofs ( )

inline

Update the previous dofs.

     {
       for (unsigned n = 0; n < Ndof * N_tstorage + 1; n++)
       {
         Previous_dofs[n] = Problem_pt->dof(n);
       }
     }

References oomph::Problem::dof(), n, oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::N_tstorage, oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::Previous_dofs, and oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::Problem_pt.

Referenced by oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::adapt_temporal_mesh().

Member Data Documentation

◆ Basic_time_mesh_pt

template<unsigned NNODE_1D>

Mesh* oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::Basic_time_mesh_pt

private

Storage for the mesh of temporal elements with a simple mesh pointer.

Referenced by oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::adapt_temporal_mesh().

◆ N_element_in_period

template<unsigned NNODE_1D>

unsigned oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::N_element_in_period

private

Storage for number of elements in the period.

Referenced by oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::adapt_temporal_mesh().

◆ N_tstorage

template<unsigned NNODE_1D>

unsigned oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::N_tstorage

private

Storage for the number of unknown time values.

Referenced by oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::adapt_temporal_mesh(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::eqn_number(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::ndof(), and oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::set_previous_dofs_to_current_dofs().

◆ Ndof

template<unsigned NNODE_1D>

unsigned oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::Ndof

private

Store number of degrees of freedom in the original problem.

Referenced by oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::adapt_temporal_mesh(), and oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::eqn_number().

◆ Omega

template<unsigned NNODE_1D>

double oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::Omega

private

Storage for the frequency of the orbit (scaled by 2pi)

Referenced by oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::adapt_temporal_mesh().

◆ Previous_dofs

template<unsigned NNODE_1D>

Vector<double> oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::Previous_dofs

private

Storage for the previous solution.

Referenced by oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::adapt_temporal_mesh(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::get_previous_dofs_for_element(), and oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::set_previous_dofs_to_current_dofs().

◆ Problem_pt

template<unsigned NNODE_1D>

Problem* oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::Problem_pt

private

Pointer to the problem.

Referenced by oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::adapt_temporal_mesh(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::get_dofs_for_element(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::orbit_output(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::set_dofs_for_element(), and oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::set_previous_dofs_to_current_dofs().

◆ Time_mesh_pt

template<unsigned NNODE_1D>

PeriodicOrbitTemporalMesh<SpectralPeriodicOrbitElement<NNODE_1D> >* oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::Time_mesh_pt

private

Storage for mesh of temporal elements.

Referenced by oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::adapt_temporal_mesh(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::discrete_times(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::get_jacobian(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::get_residuals(), oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::orbit_output(), and oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::~PeriodicOrbitAssemblyHandler().

◆ Time_stepper_pt

template<unsigned NNODE_1D>

PeriodicOrbitTimeDiscretisation* oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::Time_stepper_pt

private

Pointer to the timestepper.

Referenced by oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::adapt_temporal_mesh().

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

periodic_orbit_handler.h

Public Member Functions

Private Attributes

Detailed Description

template<unsigned NNODE_1D> class oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >

Constructor & Destructor Documentation

◆ PeriodicOrbitAssemblyHandler()

◆ ~PeriodicOrbitAssemblyHandler()

Member Function Documentation

◆ adapt_temporal_mesh()

◆ discrete_times()

◆ eqn_number()

◆ get_dofs_for_element()

◆ get_jacobian()

◆ get_previous_dofs_for_element()

◆ get_residuals()

◆ ndof()

◆ orbit_output()

◆ set_dofs_for_element()

◆ set_previous_dofs_to_current_dofs()

Member Data Documentation

◆ Basic_time_mesh_pt

◆ N_element_in_period

◆ N_tstorage

◆ Ndof

◆ Omega

◆ Previous_dofs

◆ Problem_pt

◆ Time_mesh_pt

◆ Time_stepper_pt

template<unsigned NNODE_1D>
class oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >