#include <nodes.h>

Inheritance diagram for oomph::Data:

Public Member Functions
virtual void	clear_copied_pointers ()

	Data ()
	Default constructor. More...

	Data (const unsigned &initial_n_value)

	Data (TimeStepper *const &time_stepper_pt, const unsigned &initial_n_value, const bool &allocate_storage=true)

	Data (const Data &data)=delete
	Broken copy constructor. More...

void	operator= (const Data &)=delete
	Broken assignment operator. More...

virtual	~Data ()
	Destructor, deallocates memory assigned for data. More...

void	set_time_stepper (TimeStepper *const &time_stepper_pt, const bool &preserve_existing_data)

TimeStepper *&	time_stepper_pt ()
	Return the pointer to the timestepper. More...

TimeStepper *const &	time_stepper_pt () const
	Return the pointer to the timestepper (const version). More...

virtual bool	is_a_copy () const

virtual bool	is_a_copy (const unsigned &i) const

void	set_value (const unsigned &i, const double &value_)

void	set_value (const unsigned &t, const unsigned &i, const double &value_)

double	value (const unsigned &i) const

double	value (const unsigned &t, const unsigned &i) const

void	value (Vector< double > &values) const
	Compute Vector of values for the Data value. More...

void	value (const unsigned &t, Vector< double > &values) const

double *	value_pt (const unsigned &i) const

double *	value_pt (const unsigned &t, const unsigned &i) const

bool	does_pointer_correspond_to_value (double *const &parameter_pt)
	Check whether the pointer parameter_pt addresses internal data values. More...

void	copy (Data *orig_data_pt)
	Copy Data values from specified Data object. More...

void	dump (std::ostream &dump_file) const
	Dump the data object to a file. More...

void	read (std::ifstream &restart_file)
	Read data object from a file. More...

long *	eqn_number_pt (const unsigned &i)
	Return the pointer to the equation number of the i-th stored variable. More...

long &	eqn_number (const unsigned &i)
	Return the equation number of the i-th stored variable. More...

long	eqn_number (const unsigned &i) const
	Return the equation number of the i-th stored variable. More...

void	pin (const unsigned &i)
	Pin the i-th stored variable. More...

void	unpin (const unsigned &i)
	Unpin the i-th stored variable. More...

void	pin_all ()
	Pin all the stored variables. More...

void	unpin_all ()
	Unpin all the stored variables. More...

bool	is_pinned (const unsigned &i) const
	Test whether the i-th variable is pinned (1: true; 0: false). More...

bool	is_segregated_solve_pinned (const unsigned &i)

void	constrain (const unsigned &i)

void	unconstrain (const unsigned &i)

void	constrain_all ()
	Constrain all the stored variables when the data is made hanging. More...

void	unconstrain_all ()
	Unconstrain all the stored variables when the data is made nonhanging. More...

bool	is_constrained (const unsigned &i)

unsigned	self_test ()

unsigned	nvalue () const
	Return number of values stored in data object (incl pinned ones). More...

unsigned	ntstorage () const

virtual void	assign_eqn_numbers (unsigned long &global_ndof, Vector< double * > &dof_pt)

virtual void	describe_dofs (std::ostream &out, const std::string &current_string) const

virtual void	resize (const unsigned &n_value)
	Change (increase) the number of values that may be stored. More...

virtual void	add_value_pt_to_map (std::map< unsigned, double * > &map_of_value_pt)

Static Public Attributes
static long	Is_pinned = -1
	Static "Magic number" to indicate pinned values. More...

static long	Is_segregated_solve_pinned = -3

static long	Is_unclassified = -10

static long	Is_constrained = -2

Protected Member Functions
virtual void	reset_copied_pointers ()

Protected Attributes
Data **	Copy_of_data_pt

unsigned	Ncopies

Static Protected Attributes
static TimeStepper *	Default_static_time_stepper_pt = new Steady<0>()
	Default (static) timestepper used in steady problems. More...

Private Member Functions
void	range_check (const unsigned &t, const unsigned &i) const

void	delete_value_storage ()

void	add_copy (Data *const &data_pt)

void	remove_copy (Data *const &data_pt)

Private Attributes
double **	Value

long *	Eqn_number

TimeStepper *	Time_stepper_pt

unsigned	Nvalue
	Number of values stored in the data object. More...

Friends
class	HijackedData

class	CopiedData

class	BoundaryNodeBase

template<class NODE_TYPE >
class	BoundaryNode

class	SolidNode

std::ostream &	operator<< (std::ostream &out, const Data &d)

Detailed Description

A class that represents a collection of data; each Data object may contain many different individual values, as would be natural in non-scalar problems. Data provides storage for auxiliary ‘history’ values that are used by TimeStepper objects to calculate the time derivatives of the stored data and also stores a pointer to the appropriate TimeStepper object. In addition, an associated (global) equation number is stored for each value.

The Data class permits copies of the stored data values and equation numbers into another Data object using the copy() function. Shallow (pointer based) copies of the values can be obtained by using specific derived classes. In such cases pointers to the objects that contain the pointer-based copies should be stored in the original Data class (in the array Copy_of_data_pt) so that resize and destruction operations can be performed safely.

Constructor & Destructor Documentation

◆ Data() [1/4]

oomph::Data::Data ( )

Default constructor.

Default: Just set pointer to (steady) timestepper. No storage for values is allocated.

     : Value(0),
       Eqn_number(0),
       Time_stepper_pt(Data::Default_static_time_stepper_pt),
       Copy_of_data_pt(0),
       Ncopies(0),
       Nvalue(0)
 #ifdef OOMPH_HAS_MPI
       ,
       Non_halo_proc_ID(-1)
 #endif
  
   {
   }

Referenced by oomph::SolidNode::SolidNode().

◆ Data() [2/4]

oomph::Data::Data ( const unsigned & initial_n_value )

Default constructor for steady problems: assign memory for initial_n_value values.

Default constructor for steady problems. Memory is assigned for a given number of values, which are assumed to be free (not pinned)

     : Value(0),
       Eqn_number(0),
       Time_stepper_pt(Data::Default_static_time_stepper_pt),
       Copy_of_data_pt(0),
       Ncopies(0),
       Nvalue(initial_n_value)
 #ifdef OOMPH_HAS_MPI
       ,
       Non_halo_proc_ID(-1)
 #endif
   {
     // Only bother to do something if there are values
     if (initial_n_value > 0)
     {
       // Allocate initial_n_value values in the value and equation number
       // storage schemes.
       Value = new double*[initial_n_value];
       Eqn_number = new long[initial_n_value];
  
       // Allocate contiguous arrays of doubles and longs to
       // hold the data values.
       double* values = new double[initial_n_value];
  
       // Set the pointers to the data values and equation numbers
       // and initialise the actual values.
       for (unsigned i = 0; i < initial_n_value; i++)
       {
         // Set the pointer from the address in the contiguous array
         Value[i] = &values[i];
         // Initialise the value to zero
         Value[i][0] = 0.0;
         // Initialise the equation number to Is_unclassified
         Eqn_number[i] = Is_unclassified;
       }
     }
   }

References Eqn_number, i, Is_unclassified, and Value.

◆ Data() [3/4]

oomph::Data::Data	(	TimeStepper *const &	time_stepper_pt_,
		const unsigned &	initial_n_value,
		const bool &	allocate_storage = `true`
	)

Constructor for unsteady problems: assign memory for initial_n_value values and any memory required by the Timestepper for the storage of history values.

Constructor for unsteady problems. Memory is assigned for a given number of values; and the additional storage required by the Timestepper. The values are assumed to be free (not pinned).

     : Value(0),
       Eqn_number(0),
       Time_stepper_pt(time_stepper_pt_),
       Copy_of_data_pt(0),
       Ncopies(0),
       Nvalue(initial_n_value)
 #ifdef OOMPH_HAS_MPI
       ,
       Non_halo_proc_ID(-1)
 #endif
   {
     // If we are in charge of allocating the storage,
     // and there are data to allocate, do so
     if ((allocate_storage) && (initial_n_value > 0))
     {
       // Allocate storage for initial_n_value equation numbers
       Eqn_number = new long[initial_n_value];
  
       // Locally cache the number of time history values
       const unsigned n_tstorage = ntstorage();
  
       // There will be initial_n_value pointers each addressing and array
       // of n_tstorage doubles.
       Value = new double*[initial_n_value];
  
       // Allocate all the data values in one big array for data locality.
       double* values = new double[initial_n_value * n_tstorage];
  
       // Set the pointers to the data values and equation numbers
       for (unsigned i = 0; i < initial_n_value; i++)
       {
         // Set the pointers to the start of the time history values
         // allocated for each value.
         Value[i] = &values[i * n_tstorage];
         // Initialise all values to zero
         for (unsigned t = 0; t < n_tstorage; t++)
         {
           Value[i][t] = 0.0;
         }
         // Initialise the equation number to be unclassified.
         Eqn_number[i] = Is_unclassified;
       }
     }
   }

References Eqn_number, i, Is_unclassified, ntstorage(), plotPSD::t, and Value.

◆ Data() [4/4]

oomph::Data::Data ( const Data & data )

delete

Broken copy constructor.

◆ ~Data()

oomph::Data::~Data ( )

virtual

Destructor, deallocates memory assigned for data.

Virtual destructor, deallocates memory assigned for data.

   {
     // If we have any copies clear their pointers
     for (unsigned i = 0; i < Ncopies; i++)
     {
       Copy_of_data_pt[i]->clear_copied_pointers();
     }
  
     // Now delete the storage allocated for pointers to the copies
     delete[] Copy_of_data_pt;
     Copy_of_data_pt = 0;
  
     // Clean up the allocated storage
     delete_value_storage();
   }

References clear_copied_pointers(), Copy_of_data_pt, delete_value_storage(), i, and Ncopies.

Member Function Documentation

◆ add_copy()

void oomph::Data::add_copy ( Data *const & data_pt )

private

Add the pointer data_pt to the array Copy_of_data_pt. This should be used whenever copies are made of the data.

Add the pointer data_pt to the internal storage used to keep track of copies of the Data object.

   {
     // Find the current number of copies
     const unsigned n_copies = Ncopies;
     // Allocate storage for the pointers to the new number of copies
     Data** new_copy_of_data_pt = new Data*[n_copies + 1];
     // Copy over the exisiting pointers
     for (unsigned i = 0; i < n_copies; i++)
     {
       new_copy_of_data_pt[i] = Copy_of_data_pt[i];
     }
     // Add the new pointer to the end
     new_copy_of_data_pt[n_copies] = data_pt;
  
     // Delete the old storage
     delete[] Copy_of_data_pt;
     // Allocate the new storage
     Copy_of_data_pt = new_copy_of_data_pt;
     // Increase the number of copies
     ++Ncopies;
   }

References Copy_of_data_pt, i, and Ncopies.

Referenced by oomph::CopiedData::CopiedData(), oomph::HijackedData::HijackedData(), oomph::BoundaryNodeBase::make_node_periodic(), and oomph::BoundaryNodeBase::make_nodes_periodic().

◆ add_value_pt_to_map()

void oomph::Data::add_value_pt_to_map ( std::map< unsigned, double * > & map_of_value_pt )

virtual

Add pointers to all unpinned and unconstrained data to a map indexed by (global) equation number

Reimplemented in oomph::SolidNode.

   {
     // How many values does it have
     const unsigned n_value = this->nvalue();
     // Find the global equation number
     for (unsigned i = 0; i < n_value; i++)
     {
       int global_eqn = this->eqn_number(i);
       // If it is a degree of freedom, add it to the map
       if (global_eqn >= 0)
       {
         map_of_value_pt[static_cast<unsigned>(global_eqn)] = this->value_pt(i);
       }
     }
   }

References eqn_number(), i, nvalue(), and value_pt().

Referenced by oomph::GeneralisedElement::add_internal_value_pt_to_map(), and oomph::SolidNode::add_value_pt_to_map().

◆ assign_eqn_numbers()

void oomph::Data::assign_eqn_numbers	(	unsigned long &	global_number,
		Vector< double * > &	dof_pt
	)

virtual

Assign global equation numbers; increment global number of unknowns, global_ndof; and add any new dofs to the dof_pt.

Assign (global) equation number. This function does NOT initialise the value because if we're using things like node position as variables in the problem they will have been set before the call to assign equation numbers and setting it to zero will wipe it out :(.

Pass:

current number of global dofs global_number (which gets incremented)
the Vector of pointers to global dofs (to which new dofs get added)

Reimplemented in oomph::SolidNode, oomph::Node, oomph::CopiedData, and oomph::HijackedData.

   {
     // Loop over the number of variables
     // Set temporary to hold range
     const unsigned eqn_number_range = Nvalue;
     for (unsigned i = 0; i < eqn_number_range; i++)
     {
 #ifdef OOMPH_HAS_MPI
       // Is the node a halo? If so, treat it as pinned for now
       // This will be overwritten with the actual equation number
       // during the synchronisation phase.
       if (is_halo())
       {
         eqn_number(i) = Is_pinned;
       }
       else
 #endif
       {
         // Boundary conditions test: if it's not a pinned or constrained
         // variable, The assign a new global equation number
         if ((!is_pinned(i)) && (!is_constrained(i)) &&
             (!is_segregated_solve_pinned(i)))
         {
           // Assign the equation number and increment global equation number
           Eqn_number[i] = global_number++;
           // Add pointer to global dof vector
           dof_pt.push_back(value_pt(i));
         }
       }
     }
   }

References Eqn_number, eqn_number(), i, is_constrained(), Is_pinned, is_pinned(), is_segregated_solve_pinned(), Nvalue, and value_pt().

Referenced by oomph::Node::assign_eqn_numbers(), oomph::BoundaryNode< NODE_TYPE >::assign_eqn_numbers(), oomph::SolidNode::assign_eqn_numbers(), and oomph::GeneralisedElement::assign_internal_eqn_numbers().

◆ clear_copied_pointers()

void oomph::Data::clear_copied_pointers ( )

virtual

Helper function that should be overloaded derived classes that contain copies of data. The function must unset (NULL out) the internal pointers to the copied data. This is used when destructing data to ensure that all pointers remain valid. The default implementation throws an error because Data cannot be a copy.

Helper function that should be overloaded classes that contain copies of data. The function must unset (NULL out) the internal pointers to the copied data. This is used when destructing data to ensure that all pointers remain valid.

Reimplemented in oomph::CopiedData, and oomph::HijackedData.

   {
     throw OomphLibError("Data can never be a copy",
                         OOMPH_CURRENT_FUNCTION,
                         OOMPH_EXCEPTION_LOCATION);
   }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by ~Data().

◆ constrain()

void oomph::Data::constrain ( const unsigned & i )

inline

Constrain the i-th stored variable when making hanging data If the data is already pinned leave it along, otherwise mark as constrained (hanging)

     {
       if (eqn_number(i) != Is_pinned)
       {
         eqn_number(i) = Is_constrained;
       }
     }

References eqn_number(), i, Is_constrained, and Is_pinned.

Referenced by oomph::Node::assign_eqn_numbers(), constrain_all(), oomph::Node::resize(), and oomph::Node::set_hanging_pt().

◆ constrain_all()

void oomph::Data::constrain_all ( )

inline

Constrain all the stored variables when the data is made hanging.

     {
       const unsigned n_value = Nvalue;
       for (unsigned i = 0; i < n_value; i++)
       {
         constrain(i);
       }
     }

References constrain(), i, and Nvalue.

Referenced by oomph::SolidNode::constrain_positions().

◆ copy()

void oomph::Data::copy ( Data * orig_data_pt )

Copy Data values from specified Data object.

   {
     // Find the amount of data stored
     const unsigned n_value = nvalue();
     const unsigned n_time = ntstorage();
  
     // Check # of values:
     const unsigned long n_value_orig = orig_data_pt->nvalue();
     if (n_value != n_value_orig)
     {
       std::ostringstream error_stream;
       error_stream << "The number of values, " << n_value
                    << " is not the same of those in the original data "
                    << n_value_orig << std::endl;
  
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
     const unsigned long n_time_orig = orig_data_pt->ntstorage();
     if (n_time != n_time_orig)
     {
       std::ostringstream error_stream;
       error_stream << "The number of time history values, " << n_time
                    << " is not the same of those in the original data "
                    << n_time_orig << std::endl;
  
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     // Read data
     for (unsigned t = 0; t < n_time; t++)
     {
       for (unsigned j = 0; j < n_value; j++)
       {
         set_value(t, j, orig_data_pt->value(t, j));
       }
     }
   }

References j, ntstorage(), nvalue(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, set_value(), plotPSD::t, and value().

Referenced by oomph::Node::copy(), oomph::Problem::copy(), and oomph::SolidNode::copy().

◆ delete_value_storage()

void oomph::Data::delete_value_storage ( )

private

Delete all storage allocated by the Data object for values and equation numbers.

Delete all the storage allocated by the Data object and set its pointers to NULL

   {
     // If we have nulled out the storage already return immediately
     if ((Value == 0) && (Eqn_number == 0))
     {
       return;
     }
  
     // Delete the double storage arrays at once (they were allocated at once)
     delete[] Value[0];
     // Delete the pointers to the arrays.
     delete[] Value;
     delete[] Eqn_number;
     // Null out the pointers
     Value = 0;
     Eqn_number = 0;
   }

References Eqn_number, and Value.

Referenced by oomph::BoundaryNodeBase::make_node_periodic(), oomph::BoundaryNodeBase::make_nodes_periodic(), and ~Data().

◆ describe_dofs()

void oomph::Data::describe_dofs	(	std::ostream &	out,
		const std::string &	current_string
	)		const

virtual

Function to describe the dofs of the Node. The ostream specifies the output stream to which the description is written; the string stores the currently assembled output that is ultimately written to the output stream by Data::describe_dofs(...); it is typically built up incrementally as we descend through the call hierarchy of this function when called from Problem::describe_dofs(...)

Function to describe the dofs of the Data. The ostream specifies the output stream to which the description is written; the string stores the currently assembled output that is ultimately written to the output stream by Data::describe_dofs(...); it is typically built up incrementally as we descend through the call hierarchy of this function when called from Problem::describe_dofs(...)

Reimplemented in oomph::SolidNode.

   {
     // Loop over the number of variables
     const unsigned eqn_number_range = Nvalue;
     for (unsigned i = 0; i < eqn_number_range; i++)
     {
       int eqn_number = Eqn_number[i];
       if (eqn_number >= 0)
       {
         // Note: The spacing around equation number is deliberate.
         // It allows for searching more easily as Eqn:<space>5<space> would
         // return a unique dof, whereas Eqn:<space>5 would also return those
         // starting with 5, such as 500.
         out << "Eqn: " << eqn_number << " | Value " << i << current_string
             << std::endl;
       }
     }
   }

References Eqn_number, eqn_number(), i, Nvalue, and out().

Referenced by oomph::GeneralisedElement::describe_dofs(), oomph::SolidNode::describe_dofs(), oomph::ElementWithExternalElement::describe_local_dofs(), oomph::ElementWithMovingNodes::describe_local_dofs(), oomph::GeneralisedElement::describe_local_dofs(), oomph::FSIWallElement::describe_local_dofs(), oomph::SpectralElement::describe_local_dofs(), and oomph::FiniteElement::describe_nodal_local_dofs().

◆ does_pointer_correspond_to_value()

bool oomph::Data::does_pointer_correspond_to_value ( double *const & parameter_pt )

Check whether the pointer parameter_pt addresses internal data values.

If pointer parameter_pt addresses internal data values then return return true, otherwise return false

   {
     // If there is no value data then return false
     if (Value == 0)
     {
       return false;
     }
  
     // Find the amount of data stored
     const unsigned n_value = nvalue();
     const unsigned n_time = ntstorage();
     const unsigned n_storage = n_value * n_time;
  
     // Pointer to the local data
     double* local_value_pt = Value[0];
  
     // Loop over data and if we find the pointer then return true
     for (unsigned i = 0; i < n_storage; ++i)
     {
       if (parameter_pt == (local_value_pt + i))
       {
         return true;
       }
     }
  
     // If we get to here we haven't found the data
     return false;
   }

References i, ntstorage(), nvalue(), and Value.

Referenced by oomph::Mesh::does_pointer_correspond_to_mesh_data(), and oomph::SolidNode::does_pointer_correspond_to_position_data().

◆ dump()

void oomph::Data::dump ( std::ostream & dump_file ) const

Dump the data object to a file.

Dump data object to a file.

   {
     // Find the amount of storage used
     const unsigned value_pt_range = nvalue();
     const unsigned time_steps_range = ntstorage();
  
     // Only write data if there is some stored
     if (value_pt_range * time_steps_range > 0)
     {
       dump_file << value_pt_range << " # number of data values" << std::endl;
       dump_file << time_steps_range << " # number of doubles for time history"
                 << std::endl;
  
       // Write data
       for (unsigned t = 0; t < time_steps_range; t++)
       {
         for (unsigned j = 0; j < value_pt_range; j++)
         {
           dump_file << value(t, j) << std::endl;
         }
       }
     }
   }

References j, ntstorage(), nvalue(), plotPSD::t, and value().

Referenced by oomph::SpineMesh::dump(), oomph::PerturbedSpineMesh::dump(), oomph::Mesh::dump(), and oomph::Node::dump().

◆ eqn_number() [1/2]

long& oomph::Data::eqn_number ( const unsigned & i )

inline

Return the equation number of the i-th stored variable.

     {
 #ifdef RANGE_CHECKING
       range_check(0, i);
 #endif
       return Eqn_number[i];
     }

References Eqn_number, i, and range_check().

◆ eqn_number() [2/2]

long oomph::Data::eqn_number ( const unsigned & i ) const

inline

Return the equation number of the i-th stored variable.

     {
 #ifdef RANGE_CHECKING
       range_check(0, i);
 #endif
       return Eqn_number[i];
     }

References Eqn_number, i, and range_check().

◆ eqn_number_pt()

long* oomph::Data::eqn_number_pt ( const unsigned & i )

inline

Return the pointer to the equation number of the i-th stored variable.

     {
 #ifdef RANGE_CHECKING
       range_check(0, i);
 #endif
       return &Eqn_number[i];
     }

References Eqn_number, i, and range_check().

Referenced by oomph::Hijacked< ELEMENT >::hijack_nodal_position_value(), oomph::Hijacked< ELEMENT >::hijack_nodal_spine_value(), and oomph::VolumeConstraintBoundingElement::set_volume_constraint_element().

◆ is_a_copy() [1/2]

virtual bool oomph::Data::is_a_copy ( ) const

inlinevirtual

Return a boolean to indicate whether the Data objact contains any copied values. A base Data object can never be a copy so the default implementation always returns false.

Reimplemented in oomph::CopiedData, and oomph::HijackedData.

     {
       return false;
     }

Referenced by oomph::Newmark< 2 >::assign_initial_data_values(), oomph::SelfStartingBDF2::assign_initial_values_impulsive(), oomph::Steady< NSTEPS >::assign_initial_values_impulsive(), oomph::Newmark< NSTEPS >::assign_initial_values_impulsive(), oomph::BDF< NSTEPS >::assign_initial_values_impulsive(), oomph::BDF< NSTEPS >::calculate_predicted_values(), oomph::TR::calculate_predicted_values(), oomph::SelfStartingBDF2::calculate_predicted_values_bdf2(), oomph::Mesh::check_for_repeated_nodes(), oomph::FourierDecomposedHelmholtzDtNBoundaryElement< ELEMENT >::complete_setup_of_dependencies(), oomph::HelmholtzDtNBoundaryElement< ELEMENT >::complete_setup_of_dependencies(), oomph::CopiedData::CopiedData(), oomph::HijackedData::HijackedData(), oomph::BoundaryNodeBase::make_node_periodic(), oomph::BoundaryNodeBase::make_nodes_periodic(), oomph::SolidNode::position_is_a_copy(), oomph::post_midpoint_update(), oomph::ContinuationStorageScheme::set_consistent_pinned_values(), set_time_stepper(), oomph::SelfStartingBDF2::shift_time_values(), oomph::IMRBase::shift_time_values(), oomph::Steady< NSTEPS >::shift_time_values(), oomph::NewmarkBDF< NSTEPS >::shift_time_values(), oomph::BDF< NSTEPS >::shift_time_values(), and oomph::TR::shift_time_values().

◆ is_a_copy() [2/2]

virtual bool oomph::Data::is_a_copy ( const unsigned & i ) const

inlinevirtual

Return flag to indicate whether the i-th value is a copy. A base Data object can never be a copy so the default implementation always returns false.

Reimplemented in oomph::CopiedData, and oomph::HijackedData.

     {
       return false;
     }

◆ is_constrained()

bool oomph::Data::is_constrained ( const unsigned & i )

inline

Test whether the i-th variable is constrained (1: true; 0: false).

     {
       return (Eqn_number[i] == Is_constrained);
     }

References Eqn_number, i, and Is_constrained.

Referenced by SurfactantProblem< ELEMENT, INTERFACE_ELEMENT >::actions_after_adapt(), assign_eqn_numbers(), oomph::Node::assign_eqn_numbers(), FlowAroundCylinderProblem< ELEMENT >::pin_all_base_flow_dofs(), oomph::LinearisedQCrouzeixRaviartElement::pin_real_or_imag(), FlowAroundCylinderProblem< ELEMENT >::unpin_all_base_flow_dofs(), and oomph::LinearisedQCrouzeixRaviartElement::unpin_real_or_imag().

◆ is_pinned()

bool oomph::Data::is_pinned ( const unsigned & i ) const

inline

Test whether the i-th variable is pinned (1: true; 0: false).

     {
       return (Eqn_number[i] == Is_pinned);
     }

References Eqn_number, i, and Is_pinned.

Referenced by oomph::TreeBasedRefineableMeshBase::adapt_mesh(), oomph::Problem::arc_length_step_solve(), assign_eqn_numbers(), oomph::Node::assign_eqn_numbers(), oomph::SolidICProblem::backup_original_state(), RefineableDrivenCavityProblem< ELEMENT >::doc_solution(), GlobalParameters::find_node_on_centerline(), TwoDDGProblem< ELEMENT >::limit(), main(), oomph::TreeBasedRefineableMeshBase::p_adapt_mesh(), oomph::SolidNode::position_is_pinned(), print_connectivity_matrix(), oomph::MyProblem::segregated_pin_indices(), oomph::ContinuationStorageScheme::set_consistent_pinned_values(), oomph::Problem::set_pinned_values_to_zero(), and oomph::WomersleyMesh< WOMERSLEY_ELEMENT >::WomersleyMesh().

◆ is_segregated_solve_pinned()

bool oomph::Data::is_segregated_solve_pinned ( const unsigned & i )

inline

Test whether the i-th variable is temporaily pinned for a segregated solve.

     {
       return Eqn_number[i] == Is_segregated_solve_pinned;
     }

References Eqn_number, i, and Is_segregated_solve_pinned.

Referenced by assign_eqn_numbers().

◆ ntstorage()

unsigned oomph::Data::ntstorage ( ) const

Return total number of doubles stored per value to record time history of each value (one for steady problems).

Return the total number of doubles stored per value to record the time history of ecah value. The information is read from the time stepper

   {
     return Time_stepper_pt->ntstorage();
   }

References oomph::TimeStepper::ntstorage(), and Time_stepper_pt.

◆ nvalue()

unsigned oomph::Data::nvalue ( ) const

inline

Return number of values stored in data object (incl pinned ones).

     {
       return Nvalue;
     }

References Nvalue.

◆ operator=()

void oomph::Data::operator= ( const Data & )

delete

Broken assignment operator.

◆ pin()

void oomph::Data::pin ( const unsigned & i )

inline

Pin the i-th stored variable.

     {
       eqn_number(i) = Is_pinned;
     }

References eqn_number(), i, and Is_pinned.

◆ pin_all()

void oomph::Data::pin_all ( )

inline

Pin all the stored variables.

     {
       const unsigned n_value = Nvalue;
       for (unsigned i = 0; i < n_value; i++)
       {
         Eqn_number[i] = Is_pinned;
       }
     }

References Eqn_number, i, Is_pinned, and Nvalue.

Referenced by oomph::Node::pin_all(), oomph::SolidNode::pin_all(), oomph::LinearisedQCrouzeixRaviartElement::pin_pressure_normalisation_dofs(), and oomph::LinearisedQCrouzeixRaviartElement::pin_real_or_imag().

◆ range_check()

void oomph::Data::range_check	(	const unsigned &	t,
		const unsigned &	i
	)		const

private

Check that the arguments are within the range of the stored data values and timesteps.

//////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////// Private function to check that the arguments are within the range of the stored data values and timesteps.

   {
     // If either the value or the time history value are out of range
     if ((i >= Nvalue) || (t >= ntstorage()))
     {
       std::ostringstream error_message;
       // Value range check
       if (i >= Nvalue)
       {
         error_message << "Range Error: Value " << i
                       << " is not in the range (0," << Nvalue - 1 << ")";
       }
       // Time range check
       if (t >= ntstorage())
       {
         error_message << "Range Error: Time Value " << t
                       << " is not in the range (0," << ntstorage() - 1 << ")";
       }
       // Throw the error
       throw OomphLibError(
         error_message.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
   }

References i, ntstorage(), Nvalue, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and plotPSD::t.

Referenced by eqn_number(), eqn_number_pt(), set_value(), value(), and value_pt().

◆ read()

void oomph::Data::read ( std::ifstream & restart_file )

Read data object from a file.

Read data object from file.

   {
     std::string input_string;
     std::ostringstream error_stream;
  
     // Find the amount of data stored
     const unsigned value_pt_range = nvalue();
     const unsigned time_steps_range = ntstorage();
  
     // Only read in data if there is some storage available
     if (value_pt_range * time_steps_range > 0)
     {
       // Read line up to termination sign
       getline(restart_file, input_string, '#');
       // Ignore rest of line
       restart_file.ignore(80, '\n');
       // Check # of values:
       const unsigned long check_nvalues = atoi(input_string.c_str());
       if (check_nvalues != value_pt_range)
       {
         error_stream
           << "Number of values stored in dump file is not equal to the amount "
           << "of storage allocated in Data object " << check_nvalues << " "
           << value_pt_range;
         if (check_nvalues > value_pt_range)
         {
           error_stream << " [ignoring extra entries]";
         }
         error_stream << std::endl;
         Node* nod_pt = dynamic_cast<Node*>(this);
         if (nod_pt != 0)
         {
           unsigned n_dim = nod_pt->ndim();
           error_stream << "Node coordinates: ";
           for (unsigned i = 0; i < n_dim; i++)
           {
             error_stream << nod_pt->x(i) << " ";
           }
           error_stream << nod_pt << " ";
 #ifdef OOMPH_HAS_MPI
           if (nod_pt->is_halo())
           {
             error_stream << " (halo)\n";
           }
           else
           {
             error_stream << " (not halo)\n";
           }
 #endif
         }
         if (check_nvalues < value_pt_range)
         {
           throw OomphLibError(error_stream.str(),
                               OOMPH_CURRENT_FUNCTION,
                               OOMPH_EXCEPTION_LOCATION);
         }
       }
  
       // Read line up to termination sign
       getline(restart_file, input_string, '#');
  
       // Ignore rest of line
       restart_file.ignore(80, '\n');
  
       // Check # of values:
       const unsigned check_ntvalues = atoi(input_string.c_str());
  
       // Dynamic run restarted from steady run
       if (check_ntvalues < time_steps_range)
       {
         std::ostringstream warning_stream;
         warning_stream << "Number of time history values in dump file is less "
                        << "than the storage allocated in Data object: "
                        << check_ntvalues << " " << time_steps_range
                        << std::endl;
         warning_stream
           << "We're using steady data as initial data for unsteady \n"
           << "run. I'll fill in the remaining history values with zeroes. \n"
           << "If you don't like this \n"
           << "you'll have to overwrite this yourself with whatever is \n "
           << "appropriate for your timestepping scheme. \n";
         // Issue the warning
         OomphLibWarning(
           warning_stream.str(), "Data::read()", OOMPH_EXCEPTION_LOCATION);
  
         // Read data
         for (unsigned t = 0; t < time_steps_range; t++)
         {
           for (unsigned j = 0; j < check_nvalues; j++)
           {
             if (t == 0)
             {
               // Read line
               getline(restart_file, input_string);
  
               // Transform to double
               if (j < value_pt_range)
               {
                 set_value(t, j, atof(input_string.c_str()));
               }
               else
               {
                 error_stream << "Not setting j=" << j
                              << " -th history restart value  [t = " << t
                              << " ] to " << atof(input_string.c_str())
                              << " because Data "
                              << " hasn't been sufficiently resized\n";
               }
             }
             else
             {
               if (j < value_pt_range)
               {
                 set_value(t, j, 0.0);
               }
               else
               {
                 error_stream << "Not setting j=" << j
                              << " -th restart history value  [t = " << t
                              << " ] to " << 0.0 << " because Data "
                              << " hasn't been sufficiently resized\n";
               }
             }
           }
         }
       }
       // Static run restarted from unsteady run
       else if (check_ntvalues > time_steps_range)
       {
         std::ostringstream warning_stream;
         warning_stream
           << "Warning: number of time history values in dump file is greater "
           << "than the storage allocated in Data object: " << check_ntvalues
           << " " << time_steps_range << std::endl;
         warning_stream << "We're using the current values from an unsteady \n"
                        << "restart file to initialise a static run. \n";
         // Issue the warning
         OomphLibWarning(
           warning_stream.str(), "Data::read()", OOMPH_EXCEPTION_LOCATION);
  
         // Read data
         for (unsigned t = 0; t < check_ntvalues; t++)
         {
           for (unsigned j = 0; j < check_nvalues; j++)
           {
             // Read line
             getline(restart_file, input_string);
             if (t == 0)
             {
               // Transform to double
               if (j < value_pt_range)
               {
                 set_value(t, j, atof(input_string.c_str()));
               }
               else
               {
                 error_stream << "Not setting j=" << j
                              << " -th restart history value  [t = " << t
                              << " ] to " << atof(input_string.c_str())
                              << " because Data "
                              << " hasn't been sufficiently resized\n";
               }
             }
           }
         }
       }
       // Proper dynamic restart
       else
       {
         // Read data
         for (unsigned t = 0; t < time_steps_range; t++)
         {
           for (unsigned j = 0; j < check_nvalues; j++)
           {
             // Read line
             getline(restart_file, input_string);
  
             // Transform to double
             if (j < value_pt_range)
             {
               set_value(t, j, atof(input_string.c_str()));
             }
             else
             {
               error_stream << "Not setting j=" << j
                            << " -th restart history value [t = " << t
                            << " ] to " << atof(input_string.c_str())
                            << " because Data "
                            << " hasn't been sufficiently resized\n";
             }
           }
         }
       }
       if (check_nvalues > value_pt_range)
       {
         OomphLibWarning(
           error_stream.str(), "Data::read()", OOMPH_EXCEPTION_LOCATION);
       }
     }
   }

References i, j, oomph::Node::ndim(), ntstorage(), nvalue(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, set_value(), oomph::Global_string_for_annotation::string(), plotPSD::t, and oomph::Node::x().

Referenced by oomph::PerturbedSpineMesh::read(), oomph::Mesh::read(), oomph::Node::read(), and oomph::SpineMesh::read().

◆ remove_copy()

void oomph::Data::remove_copy ( Data *const & data_pt )

private

Remove the pointer data_pt from the array Copy_of_data_pt. This should be used whenever copies of the data are deleted.

Remove the pointer data_pt from the internal storage used to keep track of copies

   {
     // Find the current number of copies
     const unsigned n_copies = Ncopies;
     // Index of the copy
     unsigned data_index = n_copies;
     // Check that the existing data is actually a copy
     for (unsigned i = 0; i < n_copies; i++)
     {
       if (Copy_of_data_pt[i] == data_pt)
       {
         data_index = i;
         break;
       }
     }
  
     // If we have not found an index throw an error
     if (data_index == n_copies)
     {
       std::ostringstream error_stream;
       error_stream << "Data pointer " << data_pt
                    << " is not stored as a copy of the data object " << this
                    << std::endl;
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
  
     // If we still here remove the data
     // Allocate storage for the pointers to the new number of copies
     Data** new_copy_of_data_pt = new Data*[n_copies - 1];
  
     unsigned index = 0;
     // Copy over the exisiting pointers
     for (unsigned i = 0; i < n_copies; i++)
     {
       // If we are not at the copied index
       if (i != data_index)
       {
         // Copy the data across
         new_copy_of_data_pt[index] = Copy_of_data_pt[i];
         // Increase the index
         ++index;
       }
     }
  
     // Delete the old storage
     delete[] Copy_of_data_pt;
     // Allocate the new storage
     Copy_of_data_pt = new_copy_of_data_pt;
     // Set the new number of copies
     --Ncopies;
   }

References Copy_of_data_pt, i, Ncopies, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by oomph::BoundaryNode< NODE_TYPE >::~BoundaryNode(), oomph::CopiedData::~CopiedData(), and oomph::HijackedData::~HijackedData().

◆ reset_copied_pointers()

void oomph::Data::reset_copied_pointers ( )

protectedvirtual

Helper function that should be overloaded in derived classes that can contain copies of Data. The function must reset the internal pointers to the copied data. This is used when resizing data to ensure that all the pointers remain valid. The default implementation throws an error beacause Data cannot be a copy.

Helper function that should be overloaded in classes that contain copies of Data. The function must reset the internal pointers to the copied data. This is used when resizing data to ensure that all the pointers remain valid. The base Data class cannot be a copy, so throw an error

Reimplemented in oomph::CopiedData, and oomph::HijackedData.

   {
     throw OomphLibError("Data can never be a copy",
                         OOMPH_CURRENT_FUNCTION,
                         OOMPH_EXCEPTION_LOCATION);
   }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by resize(), and set_time_stepper().

◆ resize()

void oomph::Data::resize ( const unsigned & n_value )

virtual

Change (increase) the number of values that may be stored.

Increase the number of data values stored, useful when adding additional data at a node, almost always Lagrange multipliers. Note if any of the unresized data is copied, then we assume all the resized data is copied from the same node as the unresized data.

Reimplemented in oomph::Node, oomph::CopiedData, and oomph::HijackedData.

   {
     // Find current number of values
     const unsigned n_value_old = nvalue();
     // Set the desired number of values
     const unsigned n_value_new = n_value;
  
     // If the number of values hasn't changed, do nothing
     if (n_value_new == n_value_old)
     {
       return;
     }
  
     // Put in a little safely check here
 #ifdef PARANOID
     if (n_value_new < n_value_old)
     {
       std::ostringstream error_stream;
       error_stream << "Warning : Data cannot be resized to a smaller value!"
                    << std::endl;
       throw OomphLibError(
         error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
     }
 #endif
  
     // Find amount of additional time storage required
     // N.B. We can't change timesteppers in this process
     const unsigned t_storage = ntstorage();
  
     // Create new sets of pointers of the appropriate (new) size
     double** value_new_pt = new double*[n_value_new];
     long* eqn_number_new = new long[n_value_new];
  
     // Create new array of values that is contiguous in memory
     double* values = new double[n_value_new * t_storage];
  
     // Copy the old values over into the new storage scheme
     for (unsigned i = 0; i < n_value_old; i++)
     {
       // Set pointer for the new values
       value_new_pt[i] = &values[i * t_storage];
       // Copy value
       for (unsigned t = 0; t < t_storage; t++)
       {
         value_new_pt[i][t] = Value[i][t];
       }
  
       // Copy equation number
       eqn_number_new[i] = Eqn_number[i];
     }
  
     // Loop over the new entries, set pointers and initialise data
     for (unsigned i = n_value_old; i < n_value_new; i++)
     {
       // Set the pointer
       value_new_pt[i] = &values[i * t_storage];
       // Initialise the new data values to zero
       for (unsigned t = 0; t < t_storage; t++)
       {
         value_new_pt[i][t] = 0.0;
       }
  
       // Initialise the equation number to Is_unclassified
       eqn_number_new[i] = Is_unclassified;
     }
  
     // Set the number of new values
     Nvalue = n_value_new;
  
     // Now delete the old storage and set the new pointers
     if (n_value_old != 0) delete[] Value[0];
     delete[] Value;
     Value = value_new_pt;
     delete[] Eqn_number;
     Eqn_number = eqn_number_new;
  
     // Now update pointers in any copies of this data
     for (unsigned i = 0; i < Ncopies; i++)
     {
       Copy_of_data_pt[i]->reset_copied_pointers();
     }
   }

References Copy_of_data_pt, Eqn_number, i, Is_unclassified, Ncopies, ntstorage(), Nvalue, nvalue(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, reset_copied_pointers(), plotPSD::t, and Value.

Referenced by oomph::PRefineableGeneralisedNewtonianQCrouzeixRaviartElement< DIM >::PRefineableGeneralisedNewtonianQCrouzeixRaviartElement(), oomph::PRefineableQCrouzeixRaviartElement< DIM >::PRefineableQCrouzeixRaviartElement(), and oomph::Node::resize().

◆ self_test()

unsigned oomph::Data::self_test ( )

Self-test: Have all values been classified as pinned/unpinned? Return 0 if OK.

   {
     // Initialise test flag
     bool passed = true;
  
     // Loop over all equation numbers
     const unsigned eqn_number_range = Nvalue;
     for (unsigned i = 0; i < eqn_number_range; i++)
     {
       // If the equation number has not been assigned, issue an error
       if (Eqn_number[i] == Is_unclassified)
       {
         passed = false;
         oomph_info << "\n ERROR: Failed Data::self_test() for i=" << i
                    << std::endl;
         oomph_info << "          (Value is not classified as pinned or free)"
                    << std::endl;
       }
     }
  
     // Return verdict
     if (passed)
     {
       return 0;
     }
     else
     {
       return 1;
     }
   }

References Eqn_number, i, Is_unclassified, Nvalue, and oomph::oomph_info.

Referenced by oomph::AlgebraicNode::self_test().

◆ set_time_stepper()

void oomph::Data::set_time_stepper	(	TimeStepper *const &	time_stepper_pt,
		const bool &	preserve_existing_data
	)

Set a new timestepper by resizing the appropriate storage. If already assigned the equation numbering will not be altered

Set a new TimeStepper be resizing the appropriate storage. Equation numbering (if already performed) will be unaffected. The current (zero) values will be unaffected, but all other entries will be set to zero.

   {
     // If the timestepper is unchanged do nothing
     if (Time_stepper_pt == time_stepper_pt)
     {
       return;
     }
  
     // Find the amount of data to be preserved
     // Default is just the current values
     unsigned n_preserved_tstorage = 1;
     if (preserve_existing_data)
     {
       n_preserved_tstorage = this->ntstorage();
     }
  
     // Set the new time stepper
     Time_stepper_pt = time_stepper_pt;
  
     // If the data is a copy don't mess with it
     if (this->is_a_copy())
     {
       return;
     }
  
     // Find the current number of values
     const unsigned n_value = nvalue();
  
     // IF there are data to allocate, do so
     if (n_value > 0)
     {
       // Locally cache the new number of time storage values
       const unsigned n_tstorage = time_stepper_pt->ntstorage();
  
       // Allocate all the data values in one big array for data locality.
       double* values = new double[n_value * n_tstorage];
  
       // Copy the old "preserved" values into the new storage scheme
       // Make sure that we limit the values to the level of storage
       if (n_tstorage < n_preserved_tstorage)
       {
         n_preserved_tstorage = n_tstorage;
       }
       for (unsigned i = 0; i < n_value; i++)
       {
         for (unsigned t = 0; t < n_preserved_tstorage; t++)
         {
           values[i * n_tstorage + t] = Value[i][t];
         }
       }
  
       // Now delete the old value storage
       delete[] Value[0];
  
       // Reset the pointers to the new data values
       for (unsigned i = 0; i < n_value; i++)
       {
         Value[i] = &values[i * n_tstorage];
         // Initialise all new time storage values to zero
         for (unsigned t = n_preserved_tstorage; t < n_tstorage; t++)
         {
           Value[i][t] = 0.0;
         }
       }
  
       // Update any pointers in any copies of this data
       for (unsigned i = 0; i < Ncopies; i++)
       {
         Copy_of_data_pt[i]->reset_copied_pointers();
       }
     }
   }

References Copy_of_data_pt, i, is_a_copy(), Ncopies, ntstorage(), oomph::TimeStepper::ntstorage(), nvalue(), reset_copied_pointers(), plotPSD::t, Time_stepper_pt, time_stepper_pt(), and Value.

Referenced by oomph::PeriodicOrbitAssemblyHandler< NNODE_1D >::adapt_temporal_mesh(), oomph::GeneralisedElement::set_internal_data_time_stepper(), oomph::SolidNode::set_position_time_stepper(), oomph::AxisymmetricPoroelasticityEquations::set_q_internal_timestepper(), and oomph::PoroelasticityEquations< DIM >::set_q_internal_timestepper().

◆ set_value() [1/2]

void oomph::Data::set_value	(	const unsigned &	i,
		const double &	value_
	)

inline

Set the i-th stored data value to specified value. The only reason that we require an explicit set function is because we redefine value() in the Node class to interpolate the values for nodes that are hanging and so we cannot return a reference to the value in this case.

     {
 #ifdef RANGE_CHECKING
       range_check(0, i);
 #endif
       Value[i][0] = value_;
     }

References i, range_check(), and Value.

◆ set_value() [2/2]

void oomph::Data::set_value	(	const unsigned &	t,
		const unsigned &	i,
		const double &	value_
	)

inline

Set the t-th history value of the i-th stored data value to specified value.

     {
 #ifdef RANGE_CHECKING
       range_check(t, i);
 #endif
       Value[i][t] = value_;
     }

References i, range_check(), plotPSD::t, and Value.

◆ time_stepper_pt() [1/2]

TimeStepper*& oomph::Data::time_stepper_pt ( )

inline

Return the pointer to the timestepper.

     {
       return Time_stepper_pt;
     }

References Time_stepper_pt.

◆ time_stepper_pt() [2/2]

TimeStepper* const& oomph::Data::time_stepper_pt ( ) const

inline

Return the pointer to the timestepper (const version).

     {
       return Time_stepper_pt;
     }

References Time_stepper_pt.

◆ unconstrain()

void oomph::Data::unconstrain ( const unsigned & i )

inline

Unconstrain the i-th stored variable when make the data nonhanging. Only unconstrain if it was actually constrained (hanging)

     {
       if (eqn_number(i) == Is_constrained)
       {
         eqn_number(i) = Is_unclassified;
       }
     }

References eqn_number(), i, Is_constrained, and Is_unclassified.

Referenced by oomph::Node::resize(), oomph::Node::set_hanging_pt(), oomph::Node::set_nonhanging(), and unconstrain_all().

◆ unconstrain_all()

void oomph::Data::unconstrain_all ( )

inline

Unconstrain all the stored variables when the data is made nonhanging.

     {
       const unsigned n_value = Nvalue;
       for (unsigned i = 0; i < n_value; i++)
       {
         unconstrain(i);
       }
     }

References i, Nvalue, and unconstrain().

Referenced by oomph::SolidNode::unconstrain_positions().

◆ unpin()

void oomph::Data::unpin ( const unsigned & i )

inline

Unpin the i-th stored variable.

     {
       eqn_number(i) = Is_unclassified;
     }

References eqn_number(), i, and Is_unclassified.

◆ unpin_all()

void oomph::Data::unpin_all ( )

inline

Unpin all the stored variables.

     {
       const unsigned n_value = Nvalue;
       for (unsigned i = 0; i < n_value; i++)
       {
         Eqn_number[i] = Is_unclassified;
       }
     }

References Eqn_number, i, Is_unclassified, and Nvalue.

Referenced by oomph::Node::unpin_all(), oomph::SolidNode::unpin_all(), and oomph::LinearisedQCrouzeixRaviartElement::unpin_real_or_imag().

◆ value() [1/4]

double oomph::Data::value ( const unsigned & i ) const

inline

Return i-th stored value. This function is not virtual so that it can be inlined. This means that if we have an explicit pointer to a Data object Data* data_pt->value() always returns the "raw" stored value.

     {
 #ifdef RANGE_CHECKING
       range_check(0, i);
 #endif
       return Value[i][0];
     }

References i, range_check(), and Value.

◆ value() [2/4]

double oomph::Data::value	(	const unsigned &	t,
		const unsigned &	i
	)		const

inline

Return i-th value at time level t (t=0: present, t>0: previous) This function is not virtual so that it can be inlined. This means that if we have an explicit pointer to a Data object Data* data_pt->value() always returns to the "raw" stored value.

     {
 #ifdef RANGE_CHECKING
       range_check(t, i);
 #endif
       return Value[i][t];
     }

References i, range_check(), plotPSD::t, and Value.

◆ value() [3/4]

void oomph::Data::value	(	const unsigned &	t,
		Vector< double > &	values
	)		const

Compute Vector of values (dofs or pinned) in this data at time level t (t=0: present; t>0: previous).

Compute Vector of values (dofs or pinned) at this node at time level t (t=0: present; t>0: previous)

   {
     // Loop over all the values and set the value at time level t
     const unsigned n_value = nvalue();
     for (unsigned i = 0; i < n_value; i++)
     {
       values[i] = value(t, i);
     }
   }

References i, nvalue(), plotPSD::t, and value().

◆ value() [4/4]

void oomph::Data::value ( Vector< double > & values ) const

Compute Vector of values for the Data value.

Compute Vector of values (dofs or pinned) at this Data object.

   {
     // Loop over all the values and set the appropriate value
     const unsigned n_value = nvalue();
     for (unsigned i = 0; i < n_value; i++)
     {
       values[i] = value(i);
     }
   }

References i, nvalue(), and value().

◆ value_pt() [1/2]

double* oomph::Data::value_pt ( const unsigned & i ) const

inline

Return the pointer to the i-the stored value. Typically this is required when direct access to the stored value is required, e.g. when writing functions that return a reference to a variable that is stored in a Data object.

     {
 #ifdef RANGE_CHECKING
       range_check(0, i);
 #endif
       return Value[i];
     }

References i, range_check(), and Value.

Referenced by add_value_pt_to_map(), oomph::Problem::arc_length_step_solve(), oomph::ElementWithMovingNodes::assign_all_generic_local_eqn_numbers(), oomph::SpectralElement::assign_all_generic_local_eqn_numbers(), assign_eqn_numbers(), oomph::RefineableElement::assign_hanging_local_eqn_numbers(), oomph::GeneralisedElement::assign_internal_and_external_local_eqn_numbers(), oomph::FiniteElement::assign_nodal_local_eqn_numbers(), oomph::ImmersedRigidBodyElement::centre_rotation_angle(), oomph::ImmersedRigidBodyElement::centre_x_displacement(), oomph::ImmersedRigidBodyElement::centre_y_displacement(), oomph::FpPressureAdvectionDiffusionProblem< ELEMENT >::doc_solution(), ZeroResidualGenElement::eval(), ZeroResidualGenElement::eval_pt(), Global_Physical_Variables::external_pressure(), oomph::SpinePointMarangoniSurfactantFluidInterfaceBoundingElement< ELEMENT >::fill_in_contribution_to_jacobian(), oomph::ConstraintElement::fill_in_contribution_to_residuals(), oomph::GeneralisedElement::fill_in_jacobian_from_external_by_fd(), oomph::ElementWithExternalElement::fill_in_jacobian_from_external_interaction_field_by_fd(), oomph::ElementWithExternalElement::fill_in_jacobian_from_external_interaction_geometric_by_fd(), oomph::GeneralisedElement::fill_in_jacobian_from_internal_by_fd(), oomph::FiniteElement::fill_in_jacobian_from_nodal_by_fd(), oomph::RefineableElement::fill_in_jacobian_from_nodal_by_fd(), oomph::DoubleBuoyantQCrouzeixRaviartElement< DIM >::fill_in_off_diagonal_jacobian_blocks_by_fd(), oomph::AxisymmetricQAdvectionCrouzeixRaviartElement::fill_in_off_diagonal_jacobian_blocks_by_fd(), oomph::RefineableDoubleBuoyantQCrouzeixRaviartElement< DIM >::fill_in_off_diagonal_jacobian_blocks_by_fd(), oomph::PolarCrouzeixRaviartElement::fix_pressure(), oomph::PolarTaylorHoodElement::fix_pressure(), oomph::AxisymmetricNavierStokesEquations::get_dresidual_dnodal_coordinates(), oomph::RefineableAxisymmetricNavierStokesEquations::get_dresidual_dnodal_coordinates(), oomph::GeneralisedNewtonianAxisymmetricNavierStokesEquations::get_dresidual_dnodal_coordinates(), oomph::RefineableGeneralisedNewtonianAxisymmetricNavierStokesEquations::get_dresidual_dnodal_coordinates(), oomph::GeneralisedNewtonianNavierStokesEquations< DIM >::get_dresidual_dnodal_coordinates(), oomph::RefineableGeneralisedNewtonianNavierStokesEquations< DIM >::get_dresidual_dnodal_coordinates(), oomph::NavierStokesEquations< DIM >::get_dresidual_dnodal_coordinates(), oomph::RefineableNavierStokesEquations< DIM >::get_dresidual_dnodal_coordinates(), oomph::SpaceTimeNavierStokesEquations< DIM >::get_dresidual_dnodal_coordinates(), oomph::RefineableSpaceTimeNavierStokesEquations< DIM >::get_dresidual_dnodal_coordinates(), BrethertonElement< ELEMENT >::get_jacobian(), No_Slip::no_slip_condition_first(), No_Slip::no_slip_condition_second(), oomph::PolarCrouzeixRaviartElement::p_pnst(), oomph::SpaceTimeNavierStokesEquations< DIM >::re_st(), oomph::SpaceTimeNavierStokesMixedOrderEquations< DIM >::re_st(), oomph::SpaceTimeNavierStokesEquations< DIM >::re_st_pt(), oomph::SpaceTimeNavierStokesMixedOrderEquations< DIM >::re_st_pt(), oomph::LinearisedNavierStokesEquations::set_eigenfunction_normalisation_element(), oomph::SolidICProblem::set_newmark_initial_condition_consistently(), oomph::SpaceTimeNavierStokesEquations< DIM >::st(), oomph::SpaceTimeNavierStokesEquations< DIM >::st_pt(), oomph::YoungLaplaceContactAngleElement< ELEMENT >::u(), and ZeroResidualGenElement::ZeroResidualGenElement().

◆ value_pt() [2/2]

double* oomph::Data::value_pt	(	const unsigned &	t,
		const unsigned &	i
	)		const

inline

Return the pointer to the i-th stored value, or any of its history values (const version). Typically this is required when direct access to the stored value is required, e.g. when writing functions that return a reference to a variable that is stored in a Data object.

     {
 #ifdef RANGE_CHECKING
       range_check(t, i);
 #endif
       return &Value[i][t];
     }

References i, range_check(), plotPSD::t, and Value.

Friends And Related Function Documentation

◆ BoundaryNode

template<class NODE_TYPE >

friend class BoundaryNode

friend

◆ BoundaryNodeBase

friend class BoundaryNodeBase

friend

◆ CopiedData

friend class CopiedData

friend

Referenced by oomph::SolidNode::set_external_variable_position_pt().

◆ HijackedData

friend class HijackedData

friend

◆ operator<<

std::ostream& operator<<	(	std::ostream &	out,
		const Data &	d
	)

friend

Output operator: output all values at all times, along with any extra information stored for the timestepper.

Data output operator: output equation numbers and values at all times, along with any extra information stored for the timestepper.

   {
     const unsigned nvalue = d.nvalue();
     const unsigned nt = d.ntstorage();
  
     out << "Data: [" << std::endl;
  
     for (unsigned j = 0; j < nvalue; j++)
     {
       out << "global eq " << d.eqn_number(j) << ": [";
       for (unsigned t = 0; t < nt - 1; t++)
       {
         out << d.value(t, j) << ", ";
       }
       out << d.value(nt - 1, j) << "]" << std::endl;
     }
     out << "]" << std::endl;
  
  
     return out;
   }

◆ SolidNode

friend class SolidNode

friend

Member Data Documentation

◆ Copy_of_data_pt

Data** oomph::Data::Copy_of_data_pt

protected

C-style array of any Data objects that contain copies of the current Data object's data values.

Referenced by add_copy(), remove_copy(), resize(), set_time_stepper(), and ~Data().

◆ Default_static_time_stepper_pt

TimeStepper * oomph::Data::Default_static_time_stepper_pt = new Steady<0>()

staticprotected

Default (static) timestepper used in steady problems.

Default (steady) timestepper for steady Data.

◆ Eqn_number

long* oomph::Data::Eqn_number

private

◆ Is_constrained

long oomph::Data::Is_constrained = -2

static

Static "Magic number" used in place of the equation number to indicate that the value is constrained because it is associated with non-conforming element boundaries — a hanging node — (and is therefore pinned)

Static "Magic number" to indicate that the value is constrained, usually because is it associated with non-conforming data, otherwise known as hanging nodes

Referenced by constrain(), is_constrained(), and unconstrain().

◆ Is_pinned

long oomph::Data::Is_pinned = -1

static

Static "Magic number" to indicate pinned values.

Static "Magic number" used in place of the equation number to indicate that the value is pinned.

Referenced by oomph::ElementWithMovingNodes::assign_all_generic_local_eqn_numbers(), oomph::SpectralElement::assign_all_generic_local_eqn_numbers(), assign_eqn_numbers(), oomph::ElementWithExternalElement::assign_external_interaction_data_local_eqn_numbers(), oomph::RefineableElement::assign_hanging_local_eqn_numbers(), oomph::GeneralisedElement::assign_internal_and_external_local_eqn_numbers(), oomph::FiniteElement::assign_nodal_local_eqn_numbers(), oomph::RefineableSolidElement::assign_solid_hanging_local_eqn_numbers(), oomph::SolidFiniteElement::assign_solid_local_eqn_numbers(), constrain(), is_pinned(), pin(), and pin_all().

◆ Is_segregated_solve_pinned

long oomph::Data::Is_segregated_solve_pinned = -3

static

Static "Magic number" used in place of the equation number to indicate that the value is pinned, but only for the duration of a segregated solve.

Referenced by oomph::MyProblem::check_not_segregated(), is_segregated_solve_pinned(), oomph::MyProblem::segregated_pin_indices(), and oomph::MyProblem::undo_segregated_pinning().

◆ Is_unclassified

long oomph::Data::Is_unclassified = -10

static

Static "Magic number" used in place of the equation number to denote a value that hasn't been classified as pinned or free.

Static "Magic number" to indicate values that haven't been classified as pinned or free

Referenced by oomph::ElementWithMovingNodes::assign_all_generic_local_eqn_numbers(), oomph::SpectralElement::assign_all_generic_local_eqn_numbers(), oomph::GeneralisedElement::assign_internal_and_external_local_eqn_numbers(), oomph::FiniteElement::assign_nodal_local_eqn_numbers(), Data(), resize(), self_test(), unconstrain(), oomph::MyProblem::undo_segregated_pinning(), unpin(), and unpin_all().

◆ Ncopies

unsigned oomph::Data::Ncopies

protected

Number of Data that contain copies of this Data object's values

Referenced by add_copy(), remove_copy(), resize(), set_time_stepper(), and ~Data().

◆ Nvalue

unsigned oomph::Data::Nvalue

private

Number of values stored in the data object.

Referenced by assign_eqn_numbers(), constrain_all(), describe_dofs(), nvalue(), pin_all(), range_check(), oomph::CopiedData::reset_copied_pointers(), resize(), self_test(), unconstrain_all(), and unpin_all().

◆ Time_stepper_pt

TimeStepper* oomph::Data::Time_stepper_pt

private

Pointer to a Timestepper. The inclusion of a Timestepper pointer in the Data class, ensures that time-derivatives can be calculated and storage can be managed at the low (Data) level.

Referenced by ntstorage(), set_time_stepper(), and time_stepper_pt().

◆ Value

double** oomph::Data::Value

private

C-style array of pointers to data values and possible history values. The data must be ordered in such a way that Value[i][t] gives the i-th data value at the time value t. The ordering is chosen so that all the time levels of a particular value can be access from a single pointer to a double. This is required for copying/hijacking functionality. The data should be accessed by using the member functions value(time,ival) and set_value(time,ival,value), where time=0: present.

Referenced by oomph::HijackedData::clear_copied_pointers(), oomph::CopiedData::clear_copied_pointers(), oomph::CopiedData::CopiedData(), Data(), delete_value_storage(), does_pointer_correspond_to_value(), oomph::HijackedData::HijackedData(), oomph::BoundaryNodeBase::make_node_periodic(), oomph::BoundaryNodeBase::make_nodes_periodic(), oomph::HijackedData::reset_copied_pointers(), oomph::CopiedData::reset_copied_pointers(), oomph::BoundaryNode< NODE_TYPE >::reset_copied_pointers(), resize(), oomph::SolidNode::set_external_variable_position_pt(), oomph::SolidNode::set_position_time_stepper(), set_time_stepper(), set_value(), oomph::SolidNode::SolidNode(), value(), value_pt(), oomph::CopiedData::~CopiedData(), and oomph::HijackedData::~HijackedData().

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

Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ Data() [1/4]

◆ Data() [2/4]

◆ Data() [3/4]

◆ Data() [4/4]

◆ ~Data()

Member Function Documentation

◆ add_copy()

◆ add_value_pt_to_map()

◆ assign_eqn_numbers()

◆ clear_copied_pointers()

◆ constrain()

◆ constrain_all()

◆ copy()

◆ delete_value_storage()

◆ describe_dofs()

◆ does_pointer_correspond_to_value()

◆ dump()

◆ eqn_number() [1/2]

◆ eqn_number() [2/2]

◆ eqn_number_pt()

◆ is_a_copy() [1/2]

◆ is_a_copy() [2/2]

◆ is_constrained()

◆ is_pinned()

◆ is_segregated_solve_pinned()

◆ ntstorage()

◆ nvalue()

◆ operator=()

◆ pin()

◆ pin_all()

◆ range_check()

◆ read()

◆ remove_copy()

◆ reset_copied_pointers()

◆ resize()

◆ self_test()

◆ set_time_stepper()

◆ set_value() [1/2]

◆ set_value() [2/2]

◆ time_stepper_pt() [1/2]

◆ time_stepper_pt() [2/2]

◆ unconstrain()

◆ unconstrain_all()

◆ unpin()

◆ unpin_all()

◆ value() [1/4]

◆ value() [2/4]

◆ value() [3/4]

◆ value() [4/4]

◆ value_pt() [1/2]

◆ value_pt() [2/2]

Friends And Related Function Documentation

◆ BoundaryNode

◆ BoundaryNodeBase

◆ CopiedData

◆ HijackedData

◆ operator<<

◆ SolidNode

Member Data Documentation

◆ Copy_of_data_pt

◆ Default_static_time_stepper_pt

◆ Eqn_number

◆ Is_constrained

◆ Is_pinned

◆ Is_segregated_solve_pinned

◆ Is_unclassified

◆ Ncopies

◆ Nvalue

◆ Time_stepper_pt

◆ Value