Nektar++
Public Member Functions | Protected Member Functions | Protected Attributes | Friends | List of all members
Nektar::SolverUtils::DriverArnoldi Class Reference

Base class for the development of solvers. More...

#include <DriverArnoldi.h>

Inheritance diagram for Nektar::SolverUtils::DriverArnoldi:
[legend]

Public Member Functions

Array< OneD, NekDoubleGetRealEvl (void)
 
Array< OneD, NekDoubleGetImagEvl (void)
 
- Public Member Functions inherited from Nektar::SolverUtils::Driver
virtual ~Driver ()=default
 Destructor. More...
 
SOLVER_UTILS_EXPORT void InitObject (std::ostream &out=std::cout)
 Initialise Object. More...
 
SOLVER_UTILS_EXPORT void Execute (std::ostream &out=std::cout)
 Execute driver. More...
 
SOLVER_UTILS_EXPORT Array< OneD, EquationSystemSharedPtrGetEqu ()
 

Protected Member Functions

 DriverArnoldi (const LibUtilities::SessionReaderSharedPtr pSession, const SpatialDomains::MeshGraphSharedPtr pGraph)
 Constructor. More...
 
 ~DriverArnoldi () override=default
 Destructor. More...
 
void v_InitObject (std::ostream &out=std::cout) override
 Virtual function for initialisation implementation. More...
 
void v_Execute (std::ostream &out=std::cout) override
 Virtual function for solve implementation. More...
 
void CopyArnoldiArrayToField (Array< OneD, NekDouble > &array)
 Copy Arnoldi storage to fields. More...
 
void CopyFieldToArnoldiArray (Array< OneD, NekDouble > &array)
 Copy fields to Arnoldi storage. More...
 
void CopyFwdToAdj ()
 Copy the forward field to the adjoint system in transient growth calculations. More...
 
void WriteFld (std::string file, std::vector< Array< OneD, NekDouble > > coeffs)
 Write coefficients to file. More...
 
void WriteFld (std::string file, Array< OneD, NekDouble > coeffs)
 
void WriteEvs (std::ostream &evlout, const int k, const NekDouble real, const NekDouble imag, NekDouble resid=NekConstants::kNekUnsetDouble, bool DumpInverse=true)
 
void MaskInit ()
 Init mask. More...
 
void GetMaskInfo (std::vector< std::vector< LibUtilities::EquationSharedPtr > > &selectedDomains, std::set< int > &unselectedVariables)
 
SOLVER_UTILS_EXPORT void ArnoldiSummary (std::ostream &out)
 
- Protected Member Functions inherited from Nektar::SolverUtils::Driver
 Driver (const LibUtilities::SessionReaderSharedPtr pSession, const SpatialDomains::MeshGraphSharedPtr pGraph)
 Initialises EquationSystem class members. More...
 
virtual SOLVER_UTILS_EXPORT void v_InitObject (std::ostream &out=std::cout)
 Virtual function for initialisation implementation. More...
 
virtual SOLVER_UTILS_EXPORT void v_Execute (std::ostream &out=std::cout)=0
 Virtual function for solve implementation. More...
 

Protected Attributes

int m_kdim
 
int m_nvec
 Dimension of Krylov subspace. More...
 
int m_nits
 Number of vectors to test. More...
 
NekDouble m_evtol
 Maxmum number of iterations. More...
 
NekDouble m_period
 Tolerance of iterations. More...
 
bool m_timeSteppingAlgorithm
 Period of time stepping algorithm. More...
 
int m_infosteps
 underlying operator is time stepping More...
 
int m_nfields
 interval to dump information if required. More...
 
NekDouble m_realShift
 
NekDouble m_imagShift
 
int m_negatedOp
 
Array< OneD, NekDoublem_real_evl
 Operator in solve call is negated. More...
 
Array< OneD, NekDoublem_imag_evl
 
bool m_useMask
 
Array< OneD, NekDoublem_maskCoeffs
 
Array< OneD, NekDoublem_maskPhys
 
- Protected Attributes inherited from Nektar::SolverUtils::Driver
LibUtilities::CommSharedPtr m_comm
 Communication object. More...
 
LibUtilities::SessionReaderSharedPtr m_session
 Session reader object. More...
 
LibUtilities::SessionReaderSharedPtr session_LinNS
 Coupling between SFD and arnoldi. More...
 
SpatialDomains::MeshGraphSharedPtr m_graph
 MeshGraph object. More...
 
Array< OneD, EquationSystemSharedPtrm_equ
 Equation system to solve. More...
 
int m_nequ
 number of equations More...
 
enum EvolutionOperatorType m_EvolutionOperator
 Evolution Operator. More...
 

Friends

class MemoryManager< DriverArnoldi >
 

Additional Inherited Members

- Static Protected Attributes inherited from Nektar::SolverUtils::Driver
static std::string evolutionOperatorLookupIds []
 
static std::string evolutionOperatorDef
 
static std::string driverDefault
 

Detailed Description

Base class for the development of solvers.

Definition at line 44 of file DriverArnoldi.h.

Constructor & Destructor Documentation

◆ DriverArnoldi()

Nektar::SolverUtils::DriverArnoldi::DriverArnoldi ( const LibUtilities::SessionReaderSharedPtr  pSession,
const SpatialDomains::MeshGraphSharedPtr  pGraph 
)
protected

Constructor.

Constructor

Definition at line 45 of file DriverArnoldi.cpp.

48 : Driver(pSession, pGraph)
49{
50 m_session->LoadParameter("IO_InfoSteps", m_infosteps, 1);
51}
int m_infosteps
underlying operator is time stepping
Definition: DriverArnoldi.h:67
LibUtilities::SessionReaderSharedPtr m_session
Session reader object.
Definition: Driver.h:83
Driver(const LibUtilities::SessionReaderSharedPtr pSession, const SpatialDomains::MeshGraphSharedPtr pGraph)
Initialises EquationSystem class members.
Definition: Driver.cpp:73

References m_infosteps, and Nektar::SolverUtils::Driver::m_session.

◆ ~DriverArnoldi()

Nektar::SolverUtils::DriverArnoldi::~DriverArnoldi ( )
overrideprotecteddefault

Destructor.

Member Function Documentation

◆ ArnoldiSummary()

void Nektar::SolverUtils::DriverArnoldi::ArnoldiSummary ( std::ostream &  out)
protected

Definition at line 130 of file DriverArnoldi.cpp.

131{
132 if (m_comm->GetRank() == 0)
133 {
134 if (m_session->DefinesSolverInfo("ModeType") &&
135 boost::iequals(m_session->GetSolverInfo("ModeType"), "SingleMode"))
136 {
137 out << "\tSingle Fourier mode : true " << std::endl;
138 ASSERTL0(m_session->DefinesSolverInfo("Homogeneous"),
139 "Expected a homogeneous expansion to be defined "
140 "with single mode");
141 }
142 else
143 {
144 out << "\tSingle Fourier mode : false " << std::endl;
145 }
146 if (m_session->DefinesSolverInfo("BetaZero"))
147 {
148 out << "\tBeta set to Zero : true (overrides LHom)"
149 << std::endl;
150 }
151 else
152 {
153 out << "\tBeta set to Zero : false " << std::endl;
154 }
155
157 {
158 out << "\tEvolution operator : "
159 << m_session->GetSolverInfo("EvolutionOperator") << std::endl;
160 }
161 else
162 {
163 out << "\tShift (Real,Imag) : " << m_realShift << ","
164 << m_imagShift << std::endl;
165 }
166 out << "\tKrylov-space dimension : " << m_kdim << std::endl;
167 out << "\tNumber of vectors : " << m_nvec << std::endl;
168 out << "\tMax iterations : " << m_nits << std::endl;
169 out << "\tEigenvalue tolerance : " << m_evtol << std::endl;
170 out << "======================================================"
171 << std::endl;
172 }
173}
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:208
int m_nvec
Dimension of Krylov subspace.
Definition: DriverArnoldi.h:61
bool m_timeSteppingAlgorithm
Period of time stepping algorithm.
Definition: DriverArnoldi.h:65
int m_nits
Number of vectors to test.
Definition: DriverArnoldi.h:62
NekDouble m_evtol
Maxmum number of iterations.
Definition: DriverArnoldi.h:63
LibUtilities::CommSharedPtr m_comm
Communication object.
Definition: Driver.h:80

References ASSERTL0, Nektar::SolverUtils::Driver::m_comm, m_evtol, m_imagShift, m_kdim, m_nits, m_nvec, m_realShift, Nektar::SolverUtils::Driver::m_session, and m_timeSteppingAlgorithm.

Referenced by Nektar::SolverUtils::DriverArpack::v_InitObject(), and Nektar::SolverUtils::DriverModifiedArnoldi::v_InitObject().

◆ CopyArnoldiArrayToField()

void Nektar::SolverUtils::DriverArnoldi::CopyArnoldiArrayToField ( Array< OneD, NekDouble > &  array)
protected

Copy Arnoldi storage to fields.

Copy Arnoldi array to field variables which depend from either the m_fields or m_forces

Definition at line 179 of file DriverArnoldi.cpp.

180{
181
182 Array<OneD, MultiRegions::ExpListSharedPtr> &fields =
183 m_equ[0]->UpdateFields();
184 int nq = fields[0]->GetNcoeffs();
185
186 for (int k = 0; k < m_nfields; ++k)
187 {
188 Vmath::Vcopy(nq, &array[k * nq], 1, &fields[k]->UpdateCoeffs()[0], 1);
189 fields[k]->SetPhysState(false);
190 }
191}
int m_nfields
interval to dump information if required.
Definition: DriverArnoldi.h:69
Array< OneD, EquationSystemSharedPtr > m_equ
Equation system to solve.
Definition: Driver.h:92
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.hpp:825

References Nektar::SolverUtils::Driver::m_equ, m_nfields, and Vmath::Vcopy().

Referenced by Nektar::SolverUtils::DriverModifiedArnoldi::EV_update(), and Nektar::SolverUtils::DriverArpack::v_Execute().

◆ CopyFieldToArnoldiArray()

void Nektar::SolverUtils::DriverArnoldi::CopyFieldToArnoldiArray ( Array< OneD, NekDouble > &  array)
protected

Copy fields to Arnoldi storage.

Copy field variables which depend from either the m_fields or m_forces array the Arnoldi array

Definition at line 197 of file DriverArnoldi.cpp.

198{
199
200 Array<OneD, MultiRegions::ExpListSharedPtr> fields;
201
203 {
204 // This matters for the Adaptive SFD method because
205 // m_equ[1] is the nonlinear problem with non
206 // homogeneous BCs.
207 fields = m_equ[0]->UpdateFields();
208 }
209 else
210 {
211 fields = m_equ[m_nequ - 1]->UpdateFields();
212 }
213
214 for (int k = 0; k < m_nfields; ++k)
215 {
216 int nq = fields[0]->GetNcoeffs();
217 Vmath::Vcopy(nq, &fields[k]->GetCoeffs()[0], 1, &array[k * nq], 1);
218 fields[k]->SetPhysState(false);
219 }
220}
enum EvolutionOperatorType m_EvolutionOperator
Evolution Operator.
Definition: Driver.h:98
int m_nequ
number of equations
Definition: Driver.h:95

References Nektar::SolverUtils::eAdaptiveSFD, Nektar::SolverUtils::Driver::m_equ, Nektar::SolverUtils::Driver::m_EvolutionOperator, Nektar::SolverUtils::Driver::m_nequ, m_nfields, and Vmath::Vcopy().

Referenced by Nektar::SolverUtils::DriverModifiedArnoldi::EV_update(), Nektar::SolverUtils::DriverArpack::v_Execute(), and Nektar::SolverUtils::DriverModifiedArnoldi::v_Execute().

◆ CopyFwdToAdj()

void Nektar::SolverUtils::DriverArnoldi::CopyFwdToAdj ( )
protected

Copy the forward field to the adjoint system in transient growth calculations.

Initialisation for the transient growth

Definition at line 225 of file DriverArnoldi.cpp.

226{
227 Array<OneD, MultiRegions::ExpListSharedPtr> fields;
228
230 "Transient Growth non available for Coupled Solver");
231
232 fields = m_equ[0]->UpdateFields();
233 int nq = fields[0]->GetNcoeffs();
234
235 for (int k = 0; k < m_nfields; ++k)
236 {
237 Vmath::Vcopy(nq, &fields[k]->GetCoeffs()[0], 1,
238 &m_equ[1]->UpdateFields()[k]->UpdateCoeffs()[0], 1);
239 }
240}

References ASSERTL0, Nektar::SolverUtils::Driver::m_equ, m_nfields, m_timeSteppingAlgorithm, and Vmath::Vcopy().

Referenced by Nektar::SolverUtils::DriverModifiedArnoldi::EV_update(), and Nektar::SolverUtils::DriverArpack::v_Execute().

◆ GetImagEvl()

Array< OneD, NekDouble > Nektar::SolverUtils::DriverArnoldi::GetImagEvl ( void  )
inline

Definition at line 54 of file DriverArnoldi.h.

55 {
56 return m_imag_evl;
57 }
Array< OneD, NekDouble > m_imag_evl
Definition: DriverArnoldi.h:75

References m_imag_evl.

◆ GetMaskInfo()

void Nektar::SolverUtils::DriverArnoldi::GetMaskInfo ( std::vector< std::vector< LibUtilities::EquationSharedPtr > > &  selectedDomains,
std::set< int > &  unselectedVariables 
)
protected

Definition at line 338 of file DriverArnoldi.cpp.

341{
342 selectedDomains.clear();
343 std::string domain("SelectEVCalcDomain0");
344 std::string condition("C0");
345 for (size_t i = 0; i < 10; ++i)
346 {
347 domain[domain.size() - 1] = '0' + i;
348 if (!m_session->DefinesFunction(domain))
349 {
350 break;
351 }
352 for (size_t j = 0; j < 10; ++j)
353 {
354 condition[condition.size() - 1] = '0' + j;
355 if (!m_session->DefinesFunction(domain, condition))
356 {
357 break;
358 }
359 if (j == 0)
360 {
361 selectedDomains.push_back(
362 std::vector<LibUtilities::EquationSharedPtr>());
363 }
364 selectedDomains[selectedDomains.size() - 1].push_back(
365 m_session->GetFunction(domain, condition));
366 }
367 }
368 unselectedVariables.clear();
369 std::string funName("SelectEVCalcVariables");
370 std::vector<std::string> variables = m_session->GetVariables();
371 for (size_t v = 0; v < m_nfields; ++v)
372 {
373 if (!m_session->DefinesFunction(funName, variables[v]))
374 {
375 unselectedVariables.insert(v);
376 }
377 }
378 if (unselectedVariables.size() == m_nfields)
379 {
380 unselectedVariables.clear();
381 }
382}

References m_nfields, and Nektar::SolverUtils::Driver::m_session.

Referenced by MaskInit().

◆ GetRealEvl()

Array< OneD, NekDouble > Nektar::SolverUtils::DriverArnoldi::GetRealEvl ( void  )
inline

Definition at line 49 of file DriverArnoldi.h.

50 {
51 return m_real_evl;
52 }
Array< OneD, NekDouble > m_real_evl
Operator in solve call is negated.
Definition: DriverArnoldi.h:74

References m_real_evl.

◆ MaskInit()

void Nektar::SolverUtils::DriverArnoldi::MaskInit ( )
protected

Init mask.

Definition at line 387 of file DriverArnoldi.cpp.

388{
389 std::vector<std::vector<LibUtilities::EquationSharedPtr>> selectedDomains;
390 std::set<int> unselectedVariables;
391 GetMaskInfo(selectedDomains, unselectedVariables);
392 if (selectedDomains.size() == 0 && unselectedVariables.size() == 0)
393 {
394 m_useMask = false;
395 return;
396 }
397 m_useMask = true;
398 MultiRegions::ExpListSharedPtr field = m_equ[0]->UpdateFields()[0];
399 int ncoef = field->GetNcoeffs();
400 int nphys = field->GetNpoints();
401 m_maskCoeffs = Array<OneD, double>(ncoef * m_nfields, 1.);
402 m_maskPhys = Array<OneD, double>(nphys * m_nfields, 1.);
403 for (size_t i = 0; i < field->GetExpSize(); ++i)
404 {
406 SpatialDomains::GeometrySharedPtr geom = exp->GetGeom();
407 int nv = geom->GetNumVerts();
408 NekDouble gc[3] = {0., 0., 0.};
409 NekDouble gct[3] = {0., 0., 0.};
410 for (size_t j = 0; j < nv; ++j)
411 {
412 SpatialDomains::PointGeomSharedPtr vertex = geom->GetVertex(j);
413 vertex->GetCoords(gct[0], gct[1], gct[2]);
414 gc[0] += gct[0] / NekDouble(nv);
415 gc[1] += gct[1] / NekDouble(nv);
416 gc[2] += gct[2] / NekDouble(nv);
417 }
418 int unmask = 1;
419 for (size_t m = 0; m < selectedDomains.size(); ++m)
420 {
421 unmask = 0;
422 for (size_t n = 0; n < selectedDomains[m].size(); ++n)
423 {
424 if (selectedDomains[m][n]->Evaluate(gc[0], gc[1], gc[2]) <= 0.)
425 {
426 unmask = 0;
427 break;
428 }
429 else
430 {
431 unmask = 1;
432 }
433 }
434 if (unmask == 1)
435 {
436 break;
437 }
438 }
439 for (int j = 0; j < m_nfields; ++j)
440 {
441 if (unmask == 0 || unselectedVariables.count(j))
442 {
444 exp->GetNcoeffs(), 0.,
445 &m_maskCoeffs[field->GetCoeff_Offset(i) + j * ncoef], 1);
446 Vmath::Fill(exp->GetTotPoints(), 0.,
447 &m_maskPhys[field->GetPhys_Offset(i) + j * nphys],
448 1);
449 }
450 }
451 }
452}
Array< OneD, NekDouble > m_maskCoeffs
Definition: DriverArnoldi.h:78
void GetMaskInfo(std::vector< std::vector< LibUtilities::EquationSharedPtr > > &selectedDomains, std::set< int > &unselectedVariables)
Array< OneD, NekDouble > m_maskPhys
Definition: DriverArnoldi.h:79
std::shared_ptr< Expansion > ExpansionSharedPtr
Definition: Expansion.h:66
std::shared_ptr< ExpList > ExpListSharedPtr
Shared pointer to an ExpList object.
std::shared_ptr< PointGeom > PointGeomSharedPtr
Definition: Geometry.h:57
std::shared_ptr< Geometry > GeometrySharedPtr
Definition: Geometry.h:51
double NekDouble
void Fill(int n, const T alpha, T *x, const int incx)
Fill a vector with a constant value.
Definition: Vmath.hpp:54

References FilterPython_Function::field, Vmath::Fill(), GetMaskInfo(), Nektar::SolverUtils::Driver::m_equ, m_maskCoeffs, m_maskPhys, m_nfields, and m_useMask.

Referenced by v_InitObject().

◆ v_Execute()

void Nektar::SolverUtils::DriverArnoldi::v_Execute ( std::ostream &  out = std::cout)
overrideprotectedvirtual

Virtual function for solve implementation.

Implements Nektar::SolverUtils::Driver.

Reimplemented in Nektar::SolverUtils::DriverArpack, Nektar::SolverUtils::DriverModifiedArnoldi, and Nektar::SolverUtils::DriverSteadyState.

Definition at line 122 of file DriverArnoldi.cpp.

123{
124 ASSERTL0(false, "Specific version of Arnoldi driver not implemented");
125}

References ASSERTL0.

◆ v_InitObject()

void Nektar::SolverUtils::DriverArnoldi::v_InitObject ( std::ostream &  out = std::cout)
overrideprotectedvirtual

Virtual function for initialisation implementation.

Arnoldi driver initialisation

Reimplemented from Nektar::SolverUtils::Driver.

Reimplemented in Nektar::SolverUtils::DriverArpack, Nektar::SolverUtils::DriverModifiedArnoldi, and Nektar::SolverUtils::DriverSteadyState.

Definition at line 56 of file DriverArnoldi.cpp.

57{
59 m_session->MatchSolverInfo("SolverType", "VelocityCorrectionScheme",
61
63 {
64 m_period = m_session->GetParameter("TimeStep") *
65 m_session->GetParameter("NumSteps");
66 m_nfields = m_equ[0]->UpdateFields().size() - 1;
67 }
68 else
69 {
70 m_period = 1.0;
71 m_nfields = m_equ[0]->UpdateFields().size();
72 }
73
74 if (m_session->DefinesSolverInfo("ModeType") &&
75 (boost::iequals(m_session->GetSolverInfo("ModeType"), "SingleMode") ||
76 boost::iequals(m_session->GetSolverInfo("ModeType"), "HalfMode")))
77 {
78 for (int i = 0; i < m_nfields; ++i)
79 {
80 m_equ[0]->UpdateFields()[i]->SetWaveSpace(true);
81 }
82 }
83 m_negatedOp = m_equ[0]->NegatedOp();
84
85 m_session->LoadParameter("kdim", m_kdim, 16);
86 m_session->LoadParameter("nvec", m_nvec, 2);
87 m_session->LoadParameter("nits", m_nits, 500);
88 m_session->LoadParameter("evtol", m_evtol, 1e-06);
89
90 ASSERTL0(m_kdim >= m_nvec, "nvec cannot be larger than kdim.");
91
92 m_session->LoadParameter("realShift", m_realShift, 0.0);
93 m_equ[0]->SetLambda(m_realShift);
94
95 m_session->LoadParameter("imagShift", m_imagShift, 0.0);
96
97 // The imaginary shift is applied at system assembly
98 // Only if using HOMOGENEOUS expansion and ModeType set to SingleMode
99 if (m_imagShift != 0.0)
100 {
101 if (!m_session->DefinesSolverInfo("HOMOGENEOUS") &&
102 !m_session->DefinesSolverInfo("ModeType"))
103 {
105 "Imaginary shift only supported with HOMOGENEOUS "
106 "expansion and ModeType set to SingleMode");
107 }
108 else if (!boost::iequals(m_session->GetSolverInfo("ModeType"),
109 "SingleMode"))
110 {
112 "Imaginary shift only supported with HOMOGENEOUS "
113 "expansion and ModeType set to SingleMode");
114 }
115 }
116 MaskInit();
117}
#define NEKERROR(type, msg)
Assert Level 0 – Fundamental assert which is used whether in FULLDEBUG, DEBUG or OPT compilation mode...
Definition: ErrorUtil.hpp:202
NekDouble m_period
Tolerance of iterations.
Definition: DriverArnoldi.h:64
virtual SOLVER_UTILS_EXPORT void v_InitObject(std::ostream &out=std::cout)
Virtual function for initialisation implementation.
Definition: Driver.cpp:82

References ASSERTL0, Nektar::ErrorUtil::efatal, Nektar::SolverUtils::Driver::m_equ, m_evtol, m_imagShift, m_kdim, m_negatedOp, m_nfields, m_nits, m_nvec, m_period, m_realShift, Nektar::SolverUtils::Driver::m_session, m_timeSteppingAlgorithm, MaskInit(), NEKERROR, and Nektar::SolverUtils::Driver::v_InitObject().

Referenced by Nektar::SolverUtils::DriverArpack::v_InitObject(), and Nektar::SolverUtils::DriverModifiedArnoldi::v_InitObject().

◆ WriteEvs()

void Nektar::SolverUtils::DriverArnoldi::WriteEvs ( std::ostream &  evlout,
const int  k,
const NekDouble  real,
const NekDouble  imag,
NekDouble  resid = NekConstants::kNekUnsetDouble,
bool  DumpInverse = true 
)
protected

Definition at line 286 of file DriverArnoldi.cpp.

289{
291 {
292 NekDouble abs_ev = hypot(re_ev, im_ev);
293 NekDouble ang_ev = atan2(im_ev, re_ev);
294
295 evlout << "EV: " << std::setw(2) << i << std::setw(12) << abs_ev
296 << std::setw(12) << ang_ev << std::setw(12)
297 << log(abs_ev) / m_period << std::setw(12) << ang_ev / m_period;
298
300 {
301 evlout << std::setw(12) << resid;
302 }
303 evlout << std::endl;
304 }
305 else
306 {
307 NekDouble invmag = 1.0 / (re_ev * re_ev + im_ev * im_ev);
309 if (m_negatedOp)
310 {
311 sign = -1.0;
312 }
313 else
314 {
315 sign = 1.0;
316 }
317
318 evlout << "EV: " << std::setw(2) << i << std::setw(14) << sign * re_ev
319 << std::setw(14) << sign * im_ev;
320
321 if (DumpInverse)
322 {
323 evlout << std::setw(14) << sign * re_ev * invmag + m_realShift
324 << std::setw(14) << sign * im_ev * invmag + m_imagShift;
325 }
326
328 {
329 evlout << std::setw(12) << resid;
330 }
331 evlout << std::endl;
332 }
333}
#define sign(a, b)
return the sign(b)*a
Definition: Polylib.cpp:47
static const NekDouble kNekUnsetDouble
scalarT< T > log(scalarT< T > in)
Definition: scalar.hpp:294

References Nektar::NekConstants::kNekUnsetDouble, tinysimd::log(), m_imagShift, m_negatedOp, m_period, m_realShift, m_timeSteppingAlgorithm, and sign.

Referenced by Nektar::SolverUtils::DriverModifiedArnoldi::EV_post(), Nektar::SolverUtils::DriverModifiedArnoldi::EV_test(), and Nektar::SolverUtils::DriverArpack::v_Execute().

◆ WriteFld() [1/2]

void Nektar::SolverUtils::DriverArnoldi::WriteFld ( std::string  file,
Array< OneD, NekDouble coeffs 
)
protected

Definition at line 263 of file DriverArnoldi.cpp.

264{
265
266 std::vector<std::string> variables(m_nfields);
267 std::vector<Array<OneD, NekDouble>> fieldcoeffs(m_nfields);
268
269 int ncoeffs = m_equ[0]->UpdateFields()[0]->GetNcoeffs();
270 ASSERTL1(coeffs.size() >= ncoeffs * m_nfields,
271 "coeffs is not of sufficient size");
272
273 for (int i = 0; i < m_nfields; ++i)
274 {
275 variables[i] = m_equ[0]->GetVariable(i);
276 fieldcoeffs[i] = coeffs + i * ncoeffs;
277 }
278
279 m_equ[0]->WriteFld(file, m_equ[0]->UpdateFields()[0], fieldcoeffs,
280 variables);
281}
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode....
Definition: ErrorUtil.hpp:242

References ASSERTL1, Nektar::SolverUtils::Driver::m_equ, and m_nfields.

◆ WriteFld() [2/2]

void Nektar::SolverUtils::DriverArnoldi::WriteFld ( std::string  file,
std::vector< Array< OneD, NekDouble > >  coeffs 
)
protected

Write coefficients to file.

Definition at line 245 of file DriverArnoldi.cpp.

247{
248
249 std::vector<std::string> variables(m_nfields);
250
251 ASSERTL1(coeffs.size() >= m_nfields, "coeffs is not of the correct length");
252 for (int i = 0; i < m_nfields; ++i)
253 {
254 variables[i] = m_equ[0]->GetVariable(i);
255 }
256
257 m_equ[0]->WriteFld(file, m_equ[0]->UpdateFields()[0], coeffs, variables);
258}

References ASSERTL1, Nektar::SolverUtils::Driver::m_equ, and m_nfields.

Referenced by Nektar::SolverUtils::DriverModifiedArnoldi::EV_post(), and Nektar::SolverUtils::DriverArpack::v_Execute().

Friends And Related Function Documentation

◆ MemoryManager< DriverArnoldi >

friend class MemoryManager< DriverArnoldi >
friend

Definition at line 1 of file DriverArnoldi.h.

Member Data Documentation

◆ m_evtol

NekDouble Nektar::SolverUtils::DriverArnoldi::m_evtol
protected

◆ m_imag_evl

Array<OneD, NekDouble> Nektar::SolverUtils::DriverArnoldi::m_imag_evl
protected

◆ m_imagShift

NekDouble Nektar::SolverUtils::DriverArnoldi::m_imagShift
protected

◆ m_infosteps

int Nektar::SolverUtils::DriverArnoldi::m_infosteps
protected

underlying operator is time stepping

Definition at line 67 of file DriverArnoldi.h.

Referenced by DriverArnoldi(), and Nektar::SolverUtils::DriverArpack::v_Execute().

◆ m_kdim

int Nektar::SolverUtils::DriverArnoldi::m_kdim
protected

◆ m_maskCoeffs

Array<OneD, NekDouble> Nektar::SolverUtils::DriverArnoldi::m_maskCoeffs
protected

◆ m_maskPhys

Array<OneD, NekDouble> Nektar::SolverUtils::DriverArnoldi::m_maskPhys
protected

Definition at line 79 of file DriverArnoldi.h.

Referenced by MaskInit().

◆ m_negatedOp

int Nektar::SolverUtils::DriverArnoldi::m_negatedOp
protected

◆ m_nfields

int Nektar::SolverUtils::DriverArnoldi::m_nfields
protected

◆ m_nits

int Nektar::SolverUtils::DriverArnoldi::m_nits
protected

◆ m_nvec

int Nektar::SolverUtils::DriverArnoldi::m_nvec
protected

◆ m_period

NekDouble Nektar::SolverUtils::DriverArnoldi::m_period
protected

Tolerance of iterations.

Definition at line 64 of file DriverArnoldi.h.

Referenced by v_InitObject(), and WriteEvs().

◆ m_real_evl

Array<OneD, NekDouble> Nektar::SolverUtils::DriverArnoldi::m_real_evl
protected

Operator in solve call is negated.

Definition at line 74 of file DriverArnoldi.h.

Referenced by GetRealEvl(), Nektar::SolverUtils::DriverArpack::v_Execute(), and Nektar::SolverUtils::DriverModifiedArnoldi::v_Execute().

◆ m_realShift

NekDouble Nektar::SolverUtils::DriverArnoldi::m_realShift
protected

◆ m_timeSteppingAlgorithm

bool Nektar::SolverUtils::DriverArnoldi::m_timeSteppingAlgorithm
protected

◆ m_useMask

bool Nektar::SolverUtils::DriverArnoldi::m_useMask
protected