Nektar++
Public Member Functions | Private Attributes | List of all members
Nektar::LibUtilities::TimeIntegrationSolutionGLM Class Reference

#include <TimeIntegrationSolutionGLM.h>

Public Member Functions

LUE TimeIntegrationSolutionGLM (const TimeIntegrationAlgorithmGLM *schemeAlgorithm, const DoubleArray &y, const NekDouble time, const NekDouble timestep)
 
LUE TimeIntegrationSolutionGLM (const TimeIntegrationAlgorithmGLM *schemeAlgorithm, const size_t nvar, const size_t npoints)
 
LUE TimeIntegrationSolutionGLM (const TimeIntegrationAlgorithmGLM *schemeAlgorithm)
 
const TimeIntegrationAlgorithmGLM * GetIntegrationSchemeData () const
 
const TripleArray & GetSolutionVector () const
 
TripleArray & UpdateSolutionVector ()
 
const DoubleArray & GetSolution () const
 
DoubleArray & UpdateSolution ()
 
void SetSolutionVector (const size_t Offset, const DoubleArray &y)
 
const Array< OneD, const NekDouble > & GetTimeVector () const
 
Array< OneD, NekDouble > & UpdateTimeVector ()
 
NekDouble GetTime () const
 
size_t GetNsteps ()
 
size_t GetFirstDim () const
 
size_t GetSecondDim () const
 
size_t GetNvalues () const
 
size_t GetNimplicitderivs () const
 
size_t GetNexplicitderivs () const
 
const Array< OneD, const size_t > & GetTimeLevelOffset ()
 
DoubleArray & GetValue (const size_t timeLevelOffset)
 
DoubleArray & GetImplicitDerivative (const size_t timeLevelOffset)
 
DoubleArray & GetExplicitDerivative (const size_t timeLevelOffset)
 
NekDouble GetValueTime (const size_t timeLevelOffset)
 
void SetValue (const size_t timeLevelOffset, const DoubleArray &y, const NekDouble t)
 
void SetImplicitDerivative (const size_t timeLevelOffset, const DoubleArray &y, const NekDouble timestep)
 
void SetExplicitDerivative (const size_t timeLevelOffset, const DoubleArray &y, const NekDouble timestep)
 
void RotateSolutionVector ()
 

Private Attributes

const TimeIntegrationAlgorithmGLM * m_schemeAlgorithm
 
TripleArray m_solVector
 
Array< OneD, NekDouble > m_t
 
Array< OneD, bool > m_setflag
 

Detailed Description

Definition at line 46 of file TimeIntegrationSolutionGLM.h.

Constructor & Destructor Documentation

◆ TimeIntegrationSolutionGLM() [1/3]

Nektar::LibUtilities::TimeIntegrationSolutionGLM::TimeIntegrationSolutionGLM ( const TimeIntegrationAlgorithmGLM *  schemeAlgorithm,
const DoubleArray &  y,
const NekDouble  time,
const NekDouble  timestep 
)

Definition at line 42 of file TimeIntegrationSolutionGLM.cpp.

45 : m_schemeAlgorithm(schemeAlgorithm),
46 m_solVector(m_schemeAlgorithm->m_numsteps),
47 m_t(m_schemeAlgorithm->m_numsteps),
48 m_setflag(m_schemeAlgorithm->m_numsteps)
49{
50 size_t nsteps = m_schemeAlgorithm->m_numsteps;
51 size_t nvar = y.size();
52 size_t npoints = y[0].size();
53 size_t nMultiStepVals = m_schemeAlgorithm->GetNmultiStepValues();
54 for (size_t i = 0; i < nsteps; i++)
55 {
56 m_solVector[i] = Array<OneD, Array<OneD, NekDouble>>(nvar);
57 for (size_t j = 0; j < nvar; j++)
58 {
59 m_solVector[i][j] = Array<OneD, NekDouble>(npoints, 0.0);
60 if (i == 0)
61 {
62 Vmath::Vcopy(npoints, y[j].get(), 1, m_solVector[i][j].get(),
63 1);
64 }
65 }
66
67 if (i < nMultiStepVals)
68 {
69 m_t[i] = time - i * timestep;
70 }
71 else
72 {
73 m_t[i] = timestep;
74 }
75
76 m_setflag[i] = (i == 0);
77 }
78}
Vmath::Vcopy
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.hpp:825

References Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::GetNmultiStepValues(), Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::m_numsteps, m_schemeAlgorithm, m_setflag, m_solVector, m_t, and Vmath::Vcopy().

◆ TimeIntegrationSolutionGLM() [2/3]

Nektar::LibUtilities::TimeIntegrationSolutionGLM::TimeIntegrationSolutionGLM ( const TimeIntegrationAlgorithmGLM *  schemeAlgorithm,
const size_t  nvar,
const size_t  npoints 
)

Definition at line 80 of file TimeIntegrationSolutionGLM.cpp.

83 : m_schemeAlgorithm(schemeAlgorithm),
84 m_solVector(schemeAlgorithm->m_numsteps),
85 m_t(schemeAlgorithm->m_numsteps),
86 m_setflag(m_schemeAlgorithm->m_numsteps, true)
87{
88 for (size_t i = 0; i < m_schemeAlgorithm->m_numsteps; i++)
89 {
90 m_solVector[i] = Array<OneD, Array<OneD, NekDouble>>(nvar);
91 for (size_t j = 0; j < nvar; j++)
92 {
93 m_solVector[i][j] = Array<OneD, NekDouble>(npoints);
94 }
95 }
96}

References Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::m_numsteps, m_schemeAlgorithm, and m_solVector.

◆ TimeIntegrationSolutionGLM() [3/3]

Nektar::LibUtilities::TimeIntegrationSolutionGLM::TimeIntegrationSolutionGLM ( const TimeIntegrationAlgorithmGLM *  schemeAlgorithm)

Definition at line 98 of file TimeIntegrationSolutionGLM.cpp.

100 : m_schemeAlgorithm(schemeAlgorithm),
101 m_solVector(m_schemeAlgorithm->m_numsteps),
102 m_t(m_schemeAlgorithm->m_numsteps),
103 m_setflag(m_schemeAlgorithm->m_numsteps, false)
104{
105}

Member Function Documentation

◆ GetExplicitDerivative()

DoubleArray & Nektar::LibUtilities::TimeIntegrationSolutionGLM::GetExplicitDerivative ( const size_t  timeLevelOffset)
inline

Definition at line 198 of file TimeIntegrationSolutionGLM.h.

199 {
200 size_t nMultiStepVals = m_schemeAlgorithm->GetNmultiStepValues();
201 size_t nMultiStepImplicitDerivs =
202 m_schemeAlgorithm->GetNmultiStepImplicitDerivs();
203 size_t size = m_schemeAlgorithm->m_numsteps;
204 const Array<OneD, const size_t> &offsetvec =
205 m_schemeAlgorithm->GetTimeLevelOffset();
206
207 for (size_t i = nMultiStepVals + nMultiStepImplicitDerivs; i < size;
208 i++)
209 {
210 if (timeLevelOffset == offsetvec[i])
211 {
212 ASSERTL0(m_setflag[i],
213 "Explicit derivative solution vector is not set at "
214 "this time level");
215 return m_solVector[i];
216 }
217 }
218 ASSERTL1(false, "The solution vector of this scheme does not contain a "
219 "derivative at the requested time-level");
220 return m_solVector[0];
221 }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:208
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode....
Definition: ErrorUtil.hpp:242
Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::GetTimeLevelOffset
const Array< OneD, const size_t > & GetTimeLevelOffset() const
Definition: TimeIntegrationAlgorithmGLM.h:161

References ASSERTL0, ASSERTL1, Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::GetNmultiStepImplicitDerivs(), Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::GetNmultiStepValues(), Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::GetTimeLevelOffset(), Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::m_numsteps, m_schemeAlgorithm, m_setflag, and m_solVector.

◆ GetFirstDim()

size_t Nektar::LibUtilities::TimeIntegrationSolutionGLM::GetFirstDim ( ) const
inline

Definition at line 110 of file TimeIntegrationSolutionGLM.h.

111 {
112 return m_solVector[0].size();
113 }

References m_solVector.

◆ GetImplicitDerivative()

DoubleArray & Nektar::LibUtilities::TimeIntegrationSolutionGLM::GetImplicitDerivative ( const size_t  timeLevelOffset)
inline

Definition at line 172 of file TimeIntegrationSolutionGLM.h.

173 {
174 size_t nMultiStepVals = m_schemeAlgorithm->GetNmultiStepValues();
175 size_t nMultiStepImplicitDerivs =
176 m_schemeAlgorithm->GetNmultiStepImplicitDerivs();
177 const Array<OneD, const size_t> &offsetvec =
178 m_schemeAlgorithm->GetTimeLevelOffset();
179
180 for (size_t i = nMultiStepVals;
181 i < nMultiStepVals + nMultiStepImplicitDerivs; i++)
182 {
183 if (timeLevelOffset == offsetvec[i])
184 {
185 ASSERTL0(m_setflag[i],
186 "Implicit derivative solution vector is not set at "
187 "this time level");
188 return m_solVector[i];
189 }
190 }
191 ASSERTL1(false, "The solution vector of this scheme does not contain a "
192 "derivative at the requested time-level");
193 return m_solVector[0];
194 }

References ASSERTL0, ASSERTL1, Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::GetNmultiStepImplicitDerivs(), Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::GetNmultiStepValues(), Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::GetTimeLevelOffset(), m_schemeAlgorithm, m_setflag, and m_solVector.

◆ GetIntegrationSchemeData()

const TimeIntegrationAlgorithmGLM * Nektar::LibUtilities::TimeIntegrationSolutionGLM::GetIntegrationSchemeData ( ) const
inline

Definition at line 60 of file TimeIntegrationSolutionGLM.h.

61 {
62 return m_schemeAlgorithm;
63 }

References m_schemeAlgorithm.

◆ GetNexplicitderivs()

size_t Nektar::LibUtilities::TimeIntegrationSolutionGLM::GetNexplicitderivs ( ) const
inline

Definition at line 136 of file TimeIntegrationSolutionGLM.h.

137 {
138 return m_schemeAlgorithm->GetNmultiStepExplicitDerivs();
139 }

References Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::GetNmultiStepExplicitDerivs(), and m_schemeAlgorithm.

◆ GetNimplicitderivs()

size_t Nektar::LibUtilities::TimeIntegrationSolutionGLM::GetNimplicitderivs ( ) const
inline

Definition at line 129 of file TimeIntegrationSolutionGLM.h.

130 {
131 return m_schemeAlgorithm->GetNmultiStepImplicitDerivs();
132 }

References Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::GetNmultiStepImplicitDerivs(), and m_schemeAlgorithm.

◆ GetNsteps()

size_t Nektar::LibUtilities::TimeIntegrationSolutionGLM::GetNsteps ( void  )
inline

Definition at line 105 of file TimeIntegrationSolutionGLM.h.

106 {
107 return m_schemeAlgorithm->m_numsteps;
108 }

References Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::m_numsteps, and m_schemeAlgorithm.

◆ GetNvalues()

size_t Nektar::LibUtilities::TimeIntegrationSolutionGLM::GetNvalues ( ) const
inline

Definition at line 122 of file TimeIntegrationSolutionGLM.h.

123 {
124 return m_schemeAlgorithm->GetNmultiStepValues();
125 }

References Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::GetNmultiStepValues(), and m_schemeAlgorithm.

◆ GetSecondDim()

size_t Nektar::LibUtilities::TimeIntegrationSolutionGLM::GetSecondDim ( ) const
inline

Definition at line 115 of file TimeIntegrationSolutionGLM.h.

116 {
117 return m_solVector[0][0].size();
118 }

References m_solVector.

◆ GetSolution()

const DoubleArray & Nektar::LibUtilities::TimeIntegrationSolutionGLM::GetSolution ( ) const
inline

Definition at line 75 of file TimeIntegrationSolutionGLM.h.

76 {
77 return m_solVector[0];
78 }

References m_solVector.

◆ GetSolutionVector()

const TripleArray & Nektar::LibUtilities::TimeIntegrationSolutionGLM::GetSolutionVector ( ) const
inline

Definition at line 65 of file TimeIntegrationSolutionGLM.h.

66 {
67 return m_solVector;
68 }

References m_solVector.

◆ GetTime()

NekDouble Nektar::LibUtilities::TimeIntegrationSolutionGLM::GetTime ( ) const
inline

Definition at line 100 of file TimeIntegrationSolutionGLM.h.

101 {
102 return m_t[0];
103 }

References m_t.

◆ GetTimeLevelOffset()

const Array< OneD, const size_t > & Nektar::LibUtilities::TimeIntegrationSolutionGLM::GetTimeLevelOffset ( )
inline

Definition at line 143 of file TimeIntegrationSolutionGLM.h.

144 {
145 return m_schemeAlgorithm->GetTimeLevelOffset();
146 }

References Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::GetTimeLevelOffset(), and m_schemeAlgorithm.

◆ GetTimeVector()

const Array< OneD, const NekDouble > & Nektar::LibUtilities::TimeIntegrationSolutionGLM::GetTimeVector ( ) const
inline

Definition at line 90 of file TimeIntegrationSolutionGLM.h.

91 {
92 return m_t;
93 }

References m_t.

◆ GetValue()

DoubleArray & Nektar::LibUtilities::TimeIntegrationSolutionGLM::GetValue ( const size_t  timeLevelOffset)
inline

Definition at line 150 of file TimeIntegrationSolutionGLM.h.

151 {
152 size_t nMultiStepVals = m_schemeAlgorithm->GetNmultiStepValues();
153 const Array<OneD, const size_t> &offsetvec =
154 m_schemeAlgorithm->GetTimeLevelOffset();
155
156 for (size_t i = 0; i < nMultiStepVals; i++)
157 {
158 if (timeLevelOffset == offsetvec[i])
159 {
160 ASSERTL0(m_setflag[i],
161 "Solution vector is not set at this time level");
162 return m_solVector[i];
163 }
164 }
165 ASSERTL1(false, "The solution vector of this scheme does not contain a "
166 "value at the requested time-level");
167 return m_solVector[0];
168 }

References ASSERTL0, ASSERTL1, Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::GetNmultiStepValues(), Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::GetTimeLevelOffset(), m_schemeAlgorithm, m_setflag, and m_solVector.

◆ GetValueTime()

NekDouble Nektar::LibUtilities::TimeIntegrationSolutionGLM::GetValueTime ( const size_t  timeLevelOffset)
inline

Definition at line 225 of file TimeIntegrationSolutionGLM.h.

226 {
227 size_t nMultiStepVals = m_schemeAlgorithm->GetNmultiStepValues();
228 const Array<OneD, const size_t> &offsetvec =
229 m_schemeAlgorithm->GetTimeLevelOffset();
230
231 for (size_t i = 0; i < nMultiStepVals; i++)
232 {
233 if (timeLevelOffset == offsetvec[i])
234 {
235 return m_t[i];
236 }
237 }
238 ASSERTL1(false, "The solution vector of this scheme does not contain a "
239 "value at the requested time-level");
240 return m_t[0];
241 }

References ASSERTL1, Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::GetNmultiStepValues(), Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::GetTimeLevelOffset(), m_schemeAlgorithm, and m_t.

◆ RotateSolutionVector()

void Nektar::LibUtilities::TimeIntegrationSolutionGLM::RotateSolutionVector ( )
inline

Definition at line 319 of file TimeIntegrationSolutionGLM.h.

320 {
321 size_t nMultiStepVals = m_schemeAlgorithm->GetNmultiStepValues();
322 size_t nMultiStepImpDerivs =
323 m_schemeAlgorithm->GetNmultiStepImplicitDerivs();
324 size_t size = m_schemeAlgorithm->m_numsteps;
325 for (size_t i = (nMultiStepVals - 1); i > 0; i--)
326 {
327 m_solVector[i] = m_solVector[i - 1];
328 m_setflag[i] = m_setflag[i - 1];
329 }
330
331 for (size_t i = (nMultiStepVals + nMultiStepImpDerivs - 1);
332 i > nMultiStepVals; i--)
333 {
334 m_solVector[i] = m_solVector[i - 1];
335 m_setflag[i] = m_setflag[i - 1];
336 }
337
338 for (size_t i = (size - 1); i > nMultiStepVals + nMultiStepImpDerivs;
339 i--)
340 {
341 m_solVector[i] = m_solVector[i - 1];
342 m_setflag[i] = m_setflag[i - 1];
343 }
344 }

References Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::GetNmultiStepImplicitDerivs(), Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::GetNmultiStepValues(), Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::m_numsteps, m_schemeAlgorithm, m_setflag, and m_solVector.

◆ SetExplicitDerivative()

void Nektar::LibUtilities::TimeIntegrationSolutionGLM::SetExplicitDerivative ( const size_t  timeLevelOffset,
const DoubleArray &  y,
const NekDouble  timestep 
)
inline

Definition at line 293 of file TimeIntegrationSolutionGLM.h.

296 {
297 size_t nMultiStepVals = m_schemeAlgorithm->GetNmultiStepValues();
298 size_t nMultiStepImplicitDerivs =
299 m_schemeAlgorithm->GetNmultiStepImplicitDerivs();
300 size_t size = m_schemeAlgorithm->m_numsteps;
301 const Array<OneD, const size_t> &offsetvec =
302 m_schemeAlgorithm->GetTimeLevelOffset();
303
304 for (size_t i = nMultiStepVals + nMultiStepImplicitDerivs; i < size;
305 i++)
306 {
307 if (timeLevelOffset == offsetvec[i])
308 {
309 m_solVector[i] = y;
310 m_t[i] = timestep;
311 m_setflag[i] = true;
312 return;
313 }
314 }
315 }

References Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::GetNmultiStepImplicitDerivs(), Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::GetNmultiStepValues(), Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::GetTimeLevelOffset(), Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::m_numsteps, m_schemeAlgorithm, m_setflag, m_solVector, and m_t.

◆ SetImplicitDerivative()

void Nektar::LibUtilities::TimeIntegrationSolutionGLM::SetImplicitDerivative ( const size_t  timeLevelOffset,
const DoubleArray &  y,
const NekDouble  timestep 
)
inline

Definition at line 267 of file TimeIntegrationSolutionGLM.h.

270 {
271 size_t nMultiStepVals = m_schemeAlgorithm->GetNmultiStepValues();
272 size_t nMultiStepImplicitDerivs =
273 m_schemeAlgorithm->GetNmultiStepImplicitDerivs();
274 const Array<OneD, const size_t> &offsetvec =
275 m_schemeAlgorithm->GetTimeLevelOffset();
276
277 for (size_t i = nMultiStepVals;
278 i < nMultiStepVals + nMultiStepImplicitDerivs; i++)
279 {
280 if (timeLevelOffset == offsetvec[i])
281 {
282 m_solVector[i] = y;
283 m_t[i] = timestep;
284 m_setflag[i] = true;
285 return;
286 }
287 }
288 }

References Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::GetNmultiStepImplicitDerivs(), Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::GetNmultiStepValues(), Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::GetTimeLevelOffset(), m_schemeAlgorithm, m_setflag, m_solVector, and m_t.

◆ SetSolutionVector()

void Nektar::LibUtilities::TimeIntegrationSolutionGLM::SetSolutionVector ( const size_t  Offset,
const DoubleArray &  y 
)
inline

Definition at line 85 of file TimeIntegrationSolutionGLM.h.

86 {
87 m_solVector[Offset] = y;
88 }

References m_solVector.

◆ SetValue()

void Nektar::LibUtilities::TimeIntegrationSolutionGLM::SetValue ( const size_t  timeLevelOffset,
const DoubleArray &  y,
const NekDouble  t 
)
inline

Definition at line 245 of file TimeIntegrationSolutionGLM.h.

247 {
248 size_t nMultiStepVals = m_schemeAlgorithm->GetNmultiStepValues();
249 const Array<OneD, const size_t> &offsetvec =
250 m_schemeAlgorithm->GetTimeLevelOffset();
251
252 for (size_t i = 0; i < nMultiStepVals; i++)
253 {
254 if (timeLevelOffset == offsetvec[i])
255 {
256 m_solVector[i] = y;
257 m_t[i] = t;
258 m_setflag[i] = true;
259 return;
260 }
261 }
262 }

References Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::GetNmultiStepValues(), Nektar::LibUtilities::TimeIntegrationAlgorithmGLM::GetTimeLevelOffset(), m_schemeAlgorithm, m_setflag, m_solVector, and m_t.

◆ UpdateSolution()

DoubleArray & Nektar::LibUtilities::TimeIntegrationSolutionGLM::UpdateSolution ( )
inline

Definition at line 80 of file TimeIntegrationSolutionGLM.h.

81 {
82 return m_solVector[0];
83 }

References m_solVector.

◆ UpdateSolutionVector()

TripleArray & Nektar::LibUtilities::TimeIntegrationSolutionGLM::UpdateSolutionVector ( )
inline

Definition at line 70 of file TimeIntegrationSolutionGLM.h.

71 {
72 return m_solVector;
73 }

References m_solVector.

◆ UpdateTimeVector()

Array< OneD, NekDouble > & Nektar::LibUtilities::TimeIntegrationSolutionGLM::UpdateTimeVector ( )
inline

Definition at line 95 of file TimeIntegrationSolutionGLM.h.

96 {
97 return m_t;
98 }

References m_t.

Member Data Documentation

◆ m_schemeAlgorithm

const TimeIntegrationAlgorithmGLM* Nektar::LibUtilities::TimeIntegrationSolutionGLM::m_schemeAlgorithm
private

Definition at line 347 of file TimeIntegrationSolutionGLM.h.

Referenced by GetExplicitDerivative(), GetImplicitDerivative(), GetIntegrationSchemeData(), GetNexplicitderivs(), GetNimplicitderivs(), GetNsteps(), GetNvalues(), GetTimeLevelOffset(), GetValue(), GetValueTime(), RotateSolutionVector(), SetExplicitDerivative(), SetImplicitDerivative(), SetValue(), and TimeIntegrationSolutionGLM().

◆ m_setflag

Array<OneD, bool> Nektar::LibUtilities::TimeIntegrationSolutionGLM::m_setflag
private

Definition at line 351 of file TimeIntegrationSolutionGLM.h.

Referenced by GetExplicitDerivative(), GetImplicitDerivative(), GetValue(), RotateSolutionVector(), SetExplicitDerivative(), SetImplicitDerivative(), SetValue(), and TimeIntegrationSolutionGLM().

◆ m_solVector

TripleArray Nektar::LibUtilities::TimeIntegrationSolutionGLM::m_solVector
private

Definition at line 349 of file TimeIntegrationSolutionGLM.h.

Referenced by GetExplicitDerivative(), GetFirstDim(), GetImplicitDerivative(), GetSecondDim(), GetSolution(), GetSolutionVector(), GetValue(), RotateSolutionVector(), SetExplicitDerivative(), SetImplicitDerivative(), SetSolutionVector(), SetValue(), TimeIntegrationSolutionGLM(), UpdateSolution(), and UpdateSolutionVector().

◆ m_t

Array<OneD, NekDouble> Nektar::LibUtilities::TimeIntegrationSolutionGLM::m_t
private

Definition at line 350 of file TimeIntegrationSolutionGLM.h.

Referenced by GetTime(), GetTimeVector(), GetValueTime(), SetExplicitDerivative(), SetImplicitDerivative(), SetValue(), TimeIntegrationSolutionGLM(), and UpdateTimeVector().

Generated on Wed Jan 31 2024 09:36:03 for Nektar++ by doxygen 1.9.4