CppNoddy  0.92
Loading...
Searching...
No Matches
Classes | Public Member Functions | Protected Attributes | List of all members
CppNoddy::HST::Rayleigh< _Type > Class Template Reference

#include <HST.h>

Public Member Functions

 Rayleigh (OneD_Node_Mesh< _Type, _Type > &base_flow_solution, double &alpha, const std::string &right_bc_type="BL")
 ctor – either for a complex solution in the complex plane, or a double solution along the real line. More...
 
void global_evp ()
 Solve the global eigenvalue problem for the Rayleigh equation by employing a second-order finite-difference matrix. More...
 
void local_evp (std::size_t i_ev)
 Solve the EVP locally as a nonlinear BVP for just one mode. More...
 
void remesh1 (const OneD_Node_Mesh< _Type, _Type > &new_baseflow)
 Refine the EIGENVECTORS mesh for a new baseflow. More...
 
OneD_Node_Mesh< std::complex< double >, _Type > & eigenvectors ()
 A handle to the eigenvectors mesh. More...
 
OneD_Node_Mesh< std::complex< double > > eigenvector (unsigned i_ev)
 
void iterate_to_neutral (std::size_t i_ev)
 Iterate on the wavenumber ALPHA, using the local_evp routine, to drive a selected eigenvalue to be neutral (ie. More...
 
DenseVector< std::complex< double > > & eigenvalues ()
 A handle to the eigenvalues vector. More...
 
double & alpha ()
 A handle to the wavenumber. More...
 
void iterate_to_neutral (std::size_t i_ev)
 
void iterate_to_neutral (std::size_t i_ev)
 
void global_evp ()
 
void global_evp ()
 

Protected Attributes

std::string RIGHT_BC_TYPE
 
double ALPHA
 
OneD_Node_Mesh< _Type, _Type > BASEFLOW
 
OneD_Node_Mesh< std::complex< double >, _Type > EIGENVECTORS
 
DenseVector< std::complex< double > > EIGENVALUES
 

Detailed Description

template<typename _Type>
class CppNoddy::HST::Rayleigh< _Type >

Definition at line 18 of file HST.h.

Constructor & Destructor Documentation

◆ Rayleigh()

template<typename _Type >
CppNoddy::HST::Rayleigh< _Type >::Rayleigh ( OneD_Node_Mesh< _Type, _Type > &  base_flow_solution,
double &  alpha,
const std::string &  right_bc_type = "BL" 
)

ctor – either for a complex solution in the complex plane, or a double solution along the real line.

Parameters
base_flow_solutionThe base flow velocity profile and its curvature.
alphaThe wavenumber of the perturbation.
right_bc_typeDetermines the choice of boundary condition. "BL" is a derivative condition, whilst "CHANNEL" is a Dirichlet impermeability condition

Definition at line 332 of file HST.h.

332 {
333 // protected data storage
334 RIGHT_BC_TYPE = right_bc_type;
335 ALPHA = alpha;
336 BASEFLOW = base_flow_solution;
337 EIGENVALUES = DenseVector<std::complex<double> >(BASEFLOW.get_nnodes(), 0.0);
338 EIGENVECTORS = OneD_Node_Mesh<std::complex<double>, _Type>(BASEFLOW.nodes(), 1);
339 }
CppNoddy::HST::Rayleigh::EIGENVECTORS
OneD_Node_Mesh< std::complex< double >, _Type > EIGENVECTORS
Definition: HST.h:149
CppNoddy::HST::Rayleigh::BASEFLOW
OneD_Node_Mesh< _Type, _Type > BASEFLOW
Definition: HST.h:148
CppNoddy::HST::Rayleigh::alpha
double & alpha()
A handle to the wavenumber.
Definition: HST.h:140
CppNoddy::HST::Rayleigh::RIGHT_BC_TYPE
std::string RIGHT_BC_TYPE
Definition: HST.h:146
CppNoddy::HST::Rayleigh::EIGENVALUES
DenseVector< std::complex< double > > EIGENVALUES
Definition: HST.h:150
CppNoddy::OneD_Node_Mesh::nodes
const DenseVector< _Xtype > & nodes() const
Definition: OneD_Node_Mesh.cpp:60
CppNoddy::OneD_Node_Mesh::get_nnodes
std::size_t get_nnodes() const
Definition: OneD_Node_Mesh.cpp:50

Member Function Documentation

◆ alpha()

template<typename _Type >
double & CppNoddy::HST::Rayleigh< _Type >::alpha ( )
inline

A handle to the wavenumber.

Returns
The wavenumber

Definition at line 140 of file HST.h.

140 {
141 return ALPHA;
142 }

References CppNoddy::HST::Rayleigh< _Type >::ALPHA.

Referenced by main().

◆ eigenvalues()

template<typename _Type >
DenseVector< std::complex< double > > & CppNoddy::HST::Rayleigh< _Type >::eigenvalues ( )
inline

A handle to the eigenvalues vector.

Returns
A vector of eigenvalues

Definition at line 134 of file HST.h.

134 {
135 return EIGENVALUES;
136 }

References CppNoddy::HST::Rayleigh< _Type >::EIGENVALUES.

Referenced by main().

◆ eigenvector()

template<typename _Type >
OneD_Node_Mesh< std::complex< double > > CppNoddy::HST::Rayleigh< _Type >::eigenvector ( unsigned  i_ev)
inline

Definition at line 118 of file HST.h.

118 {
119 unsigned n(BASEFLOW.get_nnodes());
120 OneD_Node_Mesh<std::complex<double> > temp(BASEFLOW.nodes(), 1);
121 for(unsigned i = 0; i < n; ++i) {
122 temp(i, 0) = EIGENVECTORS(i, i_ev);
123 }
124 return temp;
125 }

References CppNoddy::HST::Rayleigh< _Type >::BASEFLOW, CppNoddy::HST::Rayleigh< _Type >::EIGENVECTORS, CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::get_nnodes(), and CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::nodes().

◆ eigenvectors()

template<typename _Type >
OneD_Node_Mesh< std::complex< double >, _Type > & CppNoddy::HST::Rayleigh< _Type >::eigenvectors ( )
inline

A handle to the eigenvectors mesh.

Returns
A mesh containing the eigenvectors, with the i-th variable corresponding to the i-th eigenvalue.

Definition at line 114 of file HST.h.

114 {
115 return EIGENVECTORS;
116 }

References CppNoddy::HST::Rayleigh< _Type >::EIGENVECTORS.

◆ global_evp() [1/3]

template<typename _Type >
void CppNoddy::HST::Rayleigh< _Type >::global_evp ( )

Solve the global eigenvalue problem for the Rayleigh equation by employing a second-order finite-difference matrix.

The scheme allows for a non-uniform distribution of nodal points.

Referenced by main().

◆ global_evp() [2/3]

void CppNoddy::HST::Rayleigh< double >::global_evp ( )

Definition at line 428 of file HST.h.

428 {
429 unsigned N(BASEFLOW.get_nnodes());
430 // Rayleigh EVP -- we'll keep it complex even though its extra work
431 DenseMatrix<std::complex<double> > A(N, N, 0.0);
432 DenseMatrix<std::complex<double> > B(N, N, 0.0);
433 // f_0 = 0
434 A(0, 0) = 1.0;
435 B(0, 0) = 0.0;
436 // step through the interior nodes
437 for(std::size_t i = 1; i < N - 1; ++i) {
438#ifdef PARANOID
439 const double h1 = BASEFLOW.coord(1) - BASEFLOW.coord(0);
440 if(std::abs(BASEFLOW.coord(i) - BASEFLOW.coord(i - 1) - h1) > 1.e-12) {
441 std::string problem;
442 problem = " Warning: The Rayleigh.global_evp method is only first order \n";
443 problem += " on a non-uniform mesh.\n";
444 throw ExceptionRuntime(problem);
445 }
446#endif
447 double h(BASEFLOW.coord(i) - BASEFLOW.coord(i - 1));
448 double k(BASEFLOW.coord(i + 1) - BASEFLOW.coord(i));
449 double sigma(k / h); // sigma = 1 => uniform mesh
450 double y = BASEFLOW.coord(i);
451 double U = BASEFLOW.get_interpolated_vars(y)[ 0 ];
452 double Udd = BASEFLOW.get_interpolated_vars(y)[ 1 ];
453 double h2 = 0.5 * h * h * sigma * (sigma + 1.0);
454 A(i, i) = U * (-(sigma + 1.0) / h2 - ALPHA * ALPHA) - Udd;
455 A(i, i - 1) = sigma * U / h2;
456 A(i, i + 1) = U / h2;
457 //
458 B(i, i) = - (sigma + 1.0) / h2 - ALPHA * ALPHA;
459 B(i, i - 1) = sigma / h2;
460 B(i, i + 1) = 1. / h2;
461 }
462
463 // 3 point backward difference the far-field in BL, but pin in channel
464 if(RIGHT_BC_TYPE == "BL") {
465 double h = BASEFLOW.coord(N - 2) - BASEFLOW.coord(N - 3);
466 double k = BASEFLOW.coord(N - 1) - BASEFLOW.coord(N - 2);
467 //A( N - 1, N - 1 ) = -3.0 / ( 2 * h )- alpha;
468 //A( N - 1, N - 2 ) = 4.0 / ( 2 * h );
469 //A( N - 1, N - 3 ) = -1.0 / ( 2 * h );
470 A(N - 1, N - 1) = h * (h + k) / k * (- 1. / (h * h) + 1. / ((h + k) * (h + k))) - ALPHA;
471 A(N - 1, N - 2) = h * (h + k) / k * (1. / (h * h));
472 A(N - 1, N - 3) = h * (h + k) / k * (1. / ((h + k) * (h + k)));
473 B(N - 1, N - 1) = 0.0;
474 } else if(RIGHT_BC_TYPE == "CHANNEL") {
475 A(N - 1, N - 1) = 1.0;
476 B(N - 1, N - 1) = 0.0;
477 } else {
478 std::string problem;
479 problem = " The Rayleigh.global_evp_uniform class has been called with an unknown string \n";
480 problem += " that defines the far-field boundary condition.";
481 throw ExceptionRuntime(problem);
482 }
483 double U_max(BASEFLOW(0, 0));
484 double U_min(BASEFLOW(0, 0));
485 for(unsigned i = 1; i < N; ++i) {
486 U_max = std::max(U_max, BASEFLOW(i, 0));
487 U_min = std::min(U_min, BASEFLOW(i, 0));
488 }
489
490 DenseLinearEigenSystem<std::complex<double> > rayleigh_evp(&A, &B);
491 rayleigh_evp.eigensolve();
492 // return based on Howard's circle theorem
493 rayleigh_evp.set_shift(std::complex<double> (0.5 * (U_max + U_min), 0.0));
494 rayleigh_evp.tag_eigenvalues_disc(+1, 0.5 * (U_max - U_min));
495 EIGENVALUES = rayleigh_evp.get_tagged_eigenvalues();
496 DenseMatrix<std::complex<double> > eigenvecs_mtx = rayleigh_evp.get_tagged_eigenvectors();
497 // get eigenvectors
498 EIGENVECTORS = OneD_Node_Mesh<std::complex<double>, double>(BASEFLOW.nodes(), N);
499 for(unsigned evec = 0; evec < EIGENVALUES.size(); ++evec) {
500 for(unsigned node = 0; node < N; ++node) {
501 EIGENVECTORS(node, evec) = eigenvecs_mtx(evec, node);
502 }
503 }
504 }
U
@ U
Definition: BVPKarman.cpp:20
CppNoddy::DenseVector::size
std::size_t size() const
A pass-thru definition to get the size of the vector.
Definition: DenseVector.h:330
CppNoddy::OneD_Node_Mesh::get_interpolated_vars
DenseVector< _Type > get_interpolated_vars(const _Xtype &pos) const
Get the variable data at an interpolated position using a first order scheme.
CppNoddy::OneD_Node_Mesh::coord
const _Xtype & coord(const std::size_t &node) const
Access a nodal position.
Definition: OneD_Node_Mesh.h:278
CppNoddy::Example::A
double A(1.0)
initial hump amplitude
CppNoddy::Example::Udd
double Udd(double y)
Globally define the base flow curvature.
Definition: EVPOrrSommerfeldEasy_lapack.cpp:41
CppNoddy::Example::sigma
double sigma(100.0)

References CppNoddy::DenseLinearEigenSystem< _Type >::eigensolve(), CppNoddy::DenseLinearEigenSystem< _Type >::get_tagged_eigenvalues(), CppNoddy::DenseLinearEigenSystem< _Type >::get_tagged_eigenvectors(), h, CppNoddy::LinearEigenSystem_base::set_shift(), CppNoddy::DenseLinearEigenSystem< _Type >::tag_eigenvalues_disc(), and U.

◆ global_evp() [3/3]

void CppNoddy::HST::Rayleigh< std::complex< double > >::global_evp ( )

Definition at line 508 of file HST.h.

508 {
509 unsigned N(BASEFLOW.get_nnodes());
510 // Rayleigh EVP
511 DenseMatrix<std::complex<double> > A(N, N, 0.0);
512 DenseMatrix<std::complex<double> > B(N, N, 0.0);
513 // f_0 = 0
514 A(0, 0) = 1.0;
515 B(0, 0) = 0.0;
516 //const std::complex<double> h1 = BASEFLOW.coord( 1 ) - BASEFLOW.coord( 0 );
517 // step through the interior nodes
518 for(std::size_t i = 1; i < N - 1; ++i) {
519#ifdef PARANOID
520 const double h1 = abs(BASEFLOW.coord(1) - BASEFLOW.coord(0));
521 if(std::abs(BASEFLOW.coord(i) - BASEFLOW.coord(i - 1) - h1) > 1.e-12) {
522 std::string problem;
523 problem = " Warning: The Rayleigh.global_evp method is only first order \n";
524 problem += " on a non-uniform mesh.\n";
525 //throw ExceptionRuntime( problem );
526 }
527#endif
528 std::complex<double> h(BASEFLOW.coord(i) - BASEFLOW.coord(i - 1));
529 std::complex<double> k(BASEFLOW.coord(i + 1) - BASEFLOW.coord(i));
530 std::complex<double> sigma(k / h); // sigma = 1 => uniform mesh
531 std::complex<double> y = BASEFLOW.coord(i);
532 std::complex<double> U = BASEFLOW.get_interpolated_vars(y)[ 0 ];
533 std::complex<double> Udd = BASEFLOW.get_interpolated_vars(y)[ 1 ];
534 std::complex<double> h2 = 0.5 * h * h * sigma * (sigma + 1.0);
535 A(i, i) = U * (-(sigma + 1.0) / h2 - ALPHA * ALPHA) - Udd;
536 A(i, i - 1) = sigma * U / h2;
537 A(i, i + 1) = U / h2;
538 //
539 B(i, i) = - (sigma + 1.0) / h2 - ALPHA * ALPHA;
540 B(i, i - 1) = sigma / h2;
541 B(i, i + 1) = 1. / h2;
542 }
543
544 // 3 point backward difference the far-field in BL, but pin in channel
545 if(RIGHT_BC_TYPE == "BL") {
546 std::complex<double> h = BASEFLOW.coord(N - 2) - BASEFLOW.coord(N - 3);
547 std::complex<double> k = BASEFLOW.coord(N - 1) - BASEFLOW.coord(N - 2);
548 //A( N - 1, N - 1 ) = -3.0 / ( 2 * h )- alpha;
549 //A( N - 1, N - 2 ) = 4.0 / ( 2 * h );
550 //A( N - 1, N - 3 ) = -1.0 / ( 2 * h );
551 A(N - 1, N - 1) = h * (h + k) / k * (- 1. / (h * h) + 1. / ((h + k) * (h + k))) - ALPHA;
552 A(N - 1, N - 2) = h * (h + k) / k * (1. / (h * h));
553 A(N - 1, N - 3) = h * (h + k) / k * (1. / ((h + k) * (h + k)));
554 B(N - 1, N - 1) = 0.0;
555 } else if(RIGHT_BC_TYPE == "CHANNEL") {
556 A(N - 1, N - 1) = 1.0;
557 B(N - 1, N - 1) = 0.0;
558 } else {
559 std::string problem;
560 problem = " The Rayleigh.global_evp_uniform class has been called with an unknown string \n";
561 problem += " that defines the far-field boundary condition.";
562 throw ExceptionRuntime(problem);
563 }
564 double U_max(BASEFLOW(0, 0).real());
565 double U_min(BASEFLOW(0, 0).real());
566 for(unsigned i = 1; i < N; ++i) {
567 U_max = std::max(U_max, BASEFLOW(i, 0).real());
568 U_min = std::min(U_min, BASEFLOW(i, 0).real());
569 }
570
571 DenseLinearEigenSystem<std::complex<double> > rayleigh_evp(&A, &B);
572 rayleigh_evp.eigensolve();
573 // return based on Howard's circle theorem
574 rayleigh_evp.set_shift(std::complex<double> (0.5 * (U_max + U_min), 0.0));
575 rayleigh_evp.tag_eigenvalues_disc(+1, 0.5 * (U_max - U_min));
576 EIGENVALUES = rayleigh_evp.get_tagged_eigenvalues();
577 DenseMatrix<std::complex<double> > eigenvecs_mtx = rayleigh_evp.get_tagged_eigenvectors();
578 // get eigenvectors
579 EIGENVECTORS = OneD_Node_Mesh<std::complex<double>, std::complex<double> >(BASEFLOW.nodes(), N);
580 for(unsigned evec = 0; evec < EIGENVALUES.size(); ++evec) {
581 for(unsigned node = 0; node < N; ++node) {
582 EIGENVECTORS(node, evec) = eigenvecs_mtx(evec, node);
583 }
584 }
585 }
CppNoddy::Utility::real
DenseVector< double > real(const DenseVector< D_complex > &X)
Return a double DENSE vector containing the real part of a complex DENSE vector.
Definition: Utility.cpp:177

References CppNoddy::DenseLinearEigenSystem< _Type >::eigensolve(), CppNoddy::DenseLinearEigenSystem< _Type >::get_tagged_eigenvalues(), CppNoddy::DenseLinearEigenSystem< _Type >::get_tagged_eigenvectors(), h, CppNoddy::LinearEigenSystem_base::set_shift(), CppNoddy::DenseLinearEigenSystem< _Type >::tag_eigenvalues_disc(), and U.

◆ iterate_to_neutral() [1/3]

template<typename _Type >
void CppNoddy::HST::Rayleigh< _Type >::iterate_to_neutral ( std::size_t  i_ev)

Iterate on the wavenumber ALPHA, using the local_evp routine, to drive a selected eigenvalue to be neutral (ie.

imaginary part is zero)

Parameters
i_evThe index of the eigenvalue to iterate on

Referenced by main().

◆ iterate_to_neutral() [2/3]

void CppNoddy::HST::Rayleigh< double >::iterate_to_neutral ( std::size_t  i_ev)

Definition at line 351 of file HST.h.

351{}

◆ iterate_to_neutral() [3/3]

void CppNoddy::HST::Rayleigh< std::complex< double > >::iterate_to_neutral ( std::size_t  i_ev)

Definition at line 354 of file HST.h.

354 {
355 double delta(1.e-8);
356 do {
357 std::cout << "ALPHA = " << ALPHA << "\n";
358 local_evp(i_ev);
359 std::complex<double> copy_of_ev(EIGENVALUES[ i_ev ]);
360 ALPHA += delta;
361 local_evp(i_ev);
362 ALPHA -= delta;
363 double d_ev = (std::imag(EIGENVALUES[ i_ev ]) - std::imag(copy_of_ev)) / delta;
364 ALPHA -= std::imag(copy_of_ev) / d_ev;
365 std::cout << "ITERATING: " << ALPHA << " " << EIGENVALUES[ i_ev ] << " " << d_ev << "\n";
366 } while(std::abs(std::imag(EIGENVALUES[ i_ev ])) > 1.e-6);
367 }
CppNoddy::HST::Rayleigh::local_evp
void local_evp(std::size_t i_ev)
Solve the EVP locally as a nonlinear BVP for just one mode.
Definition: HST.h:371
CppNoddy::Example::delta
const double delta(0.5)

◆ local_evp()

template<typename _Type >
void CppNoddy::HST::Rayleigh< _Type >::local_evp ( std::size_t  i_ev)

Solve the EVP locally as a nonlinear BVP for just one mode.

Again we employ a second-order accurate finite-difference scheme which allows for non-uniform distribution of nodal points.

Parameters
i_evThe index of the eigenvalue to solve for, based on the return from the global_evp method.

Definition at line 371 of file HST.h.

371 {
372 // number of nodes in the mesh
373 std::size_t N = BASEFLOW.get_nnodes();
374 // formulate the Rayleigh equation as a BVP
375 Rayleigh_equation Rayleigh_problem;
376 // boundary conditions
377 Rayleigh_left_BC Rayleigh_left;
378 Rayleigh_right_BC_deriv Rayleigh_right_deriv;
379 Rayleigh_right_BC_Dirichlet Rayleigh_right_Dirichlet;
380 // set the private member data in the objects
381 Rayleigh_problem.p_BASEFLOW = &BASEFLOW;
382 Rayleigh_problem.p_ALPHA = &ALPHA;
383 Rayleigh_right_deriv.p_ALPHA = &ALPHA;
384
385 // pointer to the equation
386 ODE_BVP<std::complex<double>, _Type>* p_Rayleigh;
387 if(RIGHT_BC_TYPE == "BL") {
388 p_Rayleigh = new ODE_BVP<std::complex<double>, _Type>(&Rayleigh_problem, BASEFLOW.nodes(), &Rayleigh_left, &Rayleigh_right_deriv);
389 } else if(RIGHT_BC_TYPE == "CHANNEL") {
390 p_Rayleigh = new ODE_BVP<std::complex<double>, _Type>(&Rayleigh_problem, BASEFLOW.nodes(), &Rayleigh_left, &Rayleigh_right_Dirichlet);
391 } else {
392 std::string problem;
393 problem = " The Rayleigh.global_evp_uniform class has been called with an unknown string \n";
394 problem += " that defines the far-field boundary condition.";
395 throw ExceptionRuntime(problem);
396 }
397
398 p_Rayleigh -> max_itns() = 30;
399
400 // set the initial guess using the global_evp solve data
401 p_Rayleigh -> solution()(0, 0) = EIGENVECTORS(0, i_ev);
402 p_Rayleigh -> solution()(0, 1) = (EIGENVECTORS(1, i_ev) - EIGENVECTORS(0, i_ev)) / (BASEFLOW.coord(1) - BASEFLOW.coord(0));
403 p_Rayleigh -> solution()(0, 2) = EIGENVALUES[ i_ev ];
404 // set the (arbitrary) amplitude from the global_evp solve data
405 Rayleigh_left.AMPLITUDE = p_Rayleigh -> solution()(0, 1);
406 for(unsigned i = 1; i < N - 1; ++i) {
407 p_Rayleigh -> solution()(i, 0) = EIGENVECTORS(i, i_ev);
408 p_Rayleigh -> solution()(i, 1) = (EIGENVECTORS(i + 1, i_ev) - EIGENVECTORS(i - 1, i_ev)) / (BASEFLOW.coord(i + 1) - BASEFLOW.coord(i - 1));
409 p_Rayleigh -> solution()(i, 2) = EIGENVALUES[ i_ev ];
410 }
411 p_Rayleigh -> solution()(N - 1, 0) = EIGENVECTORS(N - 1, i_ev);
412 p_Rayleigh -> solution()(N - 1, 1) = (EIGENVECTORS(N - 1, i_ev) - EIGENVECTORS(N - 2, i_ev)) / (BASEFLOW.coord(N - 1) - BASEFLOW.coord(N - 2));
413 p_Rayleigh -> solution()(N - 1, 2) = EIGENVALUES[ i_ev ];
414
415 // do a local solve
416 p_Rayleigh -> solve2();
417 // write the eigenvalue and eigenvector back to private member data store
418 EIGENVALUES[ i_ev ] = p_Rayleigh -> solution()(0, 2);
419 for(unsigned i = 0; i < N; ++i) {
420 EIGENVECTORS(i, i_ev) = p_Rayleigh -> solution()(i, 0);
421 }
422 // delete the equation object
423 delete p_Rayleigh;
424 }

◆ remesh1()

template<typename _Type >
void CppNoddy::HST::Rayleigh< _Type >::remesh1 ( const OneD_Node_Mesh< _Type, _Type > &  new_baseflow)

Refine the EIGENVECTORS mesh for a new baseflow.

Useful following a global_evp solve and prior to a local_evp solve.

Parameters
new_baseflowA new mesh containing the base flow, we'll linearly interpolate to this mesh

Definition at line 343 of file HST.h.

343 {
344 // reset the baseflow mesh
345 BASEFLOW = new_baseflow;
346 // first order interpolation of the eigenvectors
347 EIGENVECTORS.remesh1(BASEFLOW.nodes());
348 }
CppNoddy::OneD_Node_Mesh::remesh1
void remesh1(const DenseVector< _Xtype > &z)
Interpolate this mesh data (linearly) into a new mesh with nodal points defined in the argument list.

References CppNoddy::OneD_Node_Mesh< _Type, _Xtype >::remesh1().

Member Data Documentation

◆ ALPHA

template<typename _Type >
double CppNoddy::HST::Rayleigh< _Type >::ALPHA
protected

Definition at line 147 of file HST.h.

Referenced by CppNoddy::HST::Rayleigh< _Type >::alpha().

◆ BASEFLOW

template<typename _Type >
OneD_Node_Mesh<_Type, _Type> CppNoddy::HST::Rayleigh< _Type >::BASEFLOW
protected

Definition at line 148 of file HST.h.

Referenced by CppNoddy::HST::Rayleigh< _Type >::eigenvector().

◆ EIGENVALUES

template<typename _Type >
DenseVector<std::complex<double> > CppNoddy::HST::Rayleigh< _Type >::EIGENVALUES
protected

Definition at line 150 of file HST.h.

Referenced by CppNoddy::HST::Rayleigh< _Type >::eigenvalues().

◆ EIGENVECTORS

template<typename _Type >
OneD_Node_Mesh<std::complex<double>, _Type> CppNoddy::HST::Rayleigh< _Type >::EIGENVECTORS
protected

Definition at line 149 of file HST.h.

Referenced by CppNoddy::HST::Rayleigh< _Type >::eigenvector(), and CppNoddy::HST::Rayleigh< _Type >::eigenvectors().

◆ RIGHT_BC_TYPE

template<typename _Type >
std::string CppNoddy::HST::Rayleigh< _Type >::RIGHT_BC_TYPE
protected

Definition at line 146 of file HST.h.

The documentation for this class was generated from the following file:
Generated on Tue Jan 1 1980 00:00:00 for CppNoddy by   doxygen 1.9.5

© 2012

R.E. Hewitt