Loading...
Searching...
No Matches
msrProblem.C
1#include "msrProblem.H"
2
3
4// Constructor
5msrProblem::msrProblem() {}
6
7msrProblem::msrProblem(int argc, char* argv[])
8{
9#include "setRootCase.H"
10#include "createTime.H"
11#include "createMesh.H"
12 _simple = autoPtr<simpleControl>
13 (
14 new simpleControl
15 (
16 mesh
17 )
18 );
19 simpleControl& simple = _simple();
20#include "createFields.H"
21#include "createFields_Neutronics.H"
22#include "createFields_Thermal.H"
23#include "createConstants.H"
24#include "createFvOptions.H"
25 turbulence->validate();
26 ITHACAdict = new IOdictionary
27 (
28 IOobject
29 (
30 "ITHACAdict",
31 runTime.system(),
32 mesh,
33 IOobject::MUST_READ,
34 IOobject::NO_WRITE
35 )
36 );
37 para = ITHACAparameters::getInstance(mesh, runTime);
38 tolerance = ITHACAdict->lookupOrDefault<scalar>("tolerance", 1e-5);
39 maxIter = ITHACAdict->lookupOrDefault<scalar>("maxIter", 1000);
40 offline = ITHACAutilities::check_off();
41 podex = ITHACAutilities::check_pod();
42}
43
44void msrProblem::truthSolve(List<scalar> mu_now)
45{
46 Time& runTime = _runTime();
47 fvMesh& mesh = _mesh();
48 volScalarField& p = _p();
49 volVectorField& U = _U();
50 surfaceScalarField& phi = _phi();
51 fv::options& fvOptions = _fvOptions();
52 simpleControl& simple = _simple();
53 IOMRFZoneList& MRF = _MRF();
54 singlePhaseTransportModel& laminarTransport = _laminarTransport();
55 dimensionedScalar& IV1 = _IV1();
56 dimensionedScalar& Keff = _Keff();
57 volScalarField& flux = _flux();
58 volScalarField flux_old = _flux();
59 dimensionedScalar& betaTot = _betaTot();
60 volScalarField& SP = _SP();
61 dimensionedScalar& SP1_0 = _SP1_0();
62 dimensionedScalar& alfa_SP1 = _alfa_SP1();
63 volScalarField& D = _D();
64 dimensionedScalar& D1_0 = _D1_0();
65 dimensionedScalar& alfa_D1 = _alfa_D1();
66 volScalarField& NSF = _NSF();
67 dimensionedScalar& NSF1_0 = _NSF1_0();
68 dimensionedScalar& alfa_NSF1 = _alfa_NSF1();
69 volScalarField& A = _A();
70 dimensionedScalar& A1_0 = _A1_0();
71 dimensionedScalar& alfa_A1 = _alfa_A1();
72 volScalarField& prec1 = _prec1();
73 dimensionedScalar& Sc = _Sc();
74 dimensionedScalar& Sct = _Sct();
75 dimensionedScalar& lam1 = _lam1();
76 dimensionedScalar& beta1 = _beta1();
77 volScalarField& prec2 = _prec2();
78 dimensionedScalar& lam2 = _lam2();
79 dimensionedScalar& beta2 = _beta2();
80 volScalarField& prec3 = _prec3();
81 dimensionedScalar& lam3 = _lam3();
82 dimensionedScalar& beta3 = _beta3();
83 volScalarField& prec4 = _prec4();
84 dimensionedScalar& lam4 = _lam4();
85 dimensionedScalar& beta4 = _beta4();
86 volScalarField& prec5 = _prec5();
87 dimensionedScalar& lam5 = _lam5();
88 dimensionedScalar& beta5 = _beta5();
89 volScalarField& prec6 = _prec6();
90 dimensionedScalar& lam6 = _lam6();
91 dimensionedScalar& beta6 = _beta6();
92 volScalarField& prec7 = _prec7();
93 dimensionedScalar& lam7 = _lam7();
94 dimensionedScalar& beta7 = _beta7();
95 volScalarField& prec8 = _prec8();
96 dimensionedScalar& lam8 = _lam8();
97 dimensionedScalar& beta8 = _beta8();
98 volScalarField& T = _T();
99 dimensionedScalar& Pr = _Pr();
100 dimensionedScalar& Prt = _Prt();
101 volScalarField& dec1 = _dec1();
102 dimensionedScalar& decLam1 = _decLam1();
103 dimensionedScalar& decBeta1 = _decBeta1();
104 volScalarField& dec2 = _dec2();
105 dimensionedScalar& decLam2 = _decLam2();
106 dimensionedScalar& decBeta2 = _decBeta2();
107 volScalarField& dec3 = _dec3();
108 dimensionedScalar& decLam3 = _decLam3();
109 dimensionedScalar& decBeta3 = _decBeta3();
110 dimensionedScalar& decbetaTot = _decbetaTot();
111 dimensionedScalar& rhoRef = _rhoRef();
112 dimensionedScalar& CpRef = _CpRef();
113 volScalarField v = _v();
114 volScalarField TXS = _TXS();
115 dimensionedScalar& nu = _nu();
116 dimensionedScalar& betaTE = _betaTE();
117 dimensionedScalar& Tref = _Tref();
118 dimensionedScalar& TrefXS = _TrefXS();
119 volScalarField& logT = _logT();
120 volScalarField& alphat = _alphat();
121 volScalarField& difft = _difft();
122 volScalarField powerDens = ((1 - decbetaTot) * flux * SP +
123 (decLam1 * dec1 + decLam2 * dec2 + decLam3 * dec3)).ref();
124 powerDens.rename("powerDens");
125#include "NLmsrProblem.H"
126 counter++;
127 writeMu(mu_now);
128 // --- Fill in the mu_samples with parameters (mu) to be used for the PODI sample points
129 mu_samples.conservativeResize(mu_samples.rows() + 1, mu_now.size());
130
131 for (label i = 0; i < mu_now.size(); i++)
132 {
133 mu_samples(mu_samples.rows() - 1, i) = mu_now[i];
134 }
135
136 // Resize to Unitary if not initialized by user (i.e. non-parametric problem)
137 if (mu.cols() == 0)
138 {
139 mu.resize(1, 1);
140 }
141
142 if (mu_samples.rows() == mu.cols())
143 {
144 ITHACAstream::exportMatrix(mu_samples, "mu_samples", "eigen",
145 "./ITHACAoutput/Offline");
146 }
147}
148
149
150// Get the modes function SVD
151void msrProblem::msrgetModesSVD()
152{
153 label NU = para->ITHACAdict->lookupOrDefault<label>("NUout", 10);
154 label NP = para->ITHACAdict->lookupOrDefault<label>("NPout", 10);
155 label NF = para->ITHACAdict->lookupOrDefault<label>("NFluxout", 10);
156 label NPrec1 = para->ITHACAdict->lookupOrDefault<label>("NPrecout1", 10);
157 label NPrec2 = para->ITHACAdict->lookupOrDefault<label>("NPrecout2", 10);
158 label NPrec3 = para->ITHACAdict->lookupOrDefault<label>("NPrecout3", 10);
159 label NPrec4 = para->ITHACAdict->lookupOrDefault<label>("NPrecout4", 10);
160 label NPrec5 = para->ITHACAdict->lookupOrDefault<label>("NPrecout5", 10);
161 label NPrec6 = para->ITHACAdict->lookupOrDefault<label>("NPrecout6", 10);
162 label NPrec7 = para->ITHACAdict->lookupOrDefault<label>("NPrecout7", 10);
163 label NPrec8 = para->ITHACAdict->lookupOrDefault<label>("NPrecout8", 10);
164 label NT = para->ITHACAdict->lookupOrDefault<label>("NTout", 10);
165 label NDec1 = para->ITHACAdict->lookupOrDefault<label>("NDecout1", 10);
166 label NDec2 = para->ITHACAdict->lookupOrDefault<label>("NDecout2", 10);
167 label NDec3 = para->ITHACAdict->lookupOrDefault<label>("NDecout3", 10);
168 label NC = para->ITHACAdict->lookupOrDefault<label>("NCout", 10);
169
170 if (homboolU == true)
171 {
172 ITHACAPOD::getModesSVD(Uomfield, Umodes, _U().name(), podex, 0, 0, NU);
173 }
174 else
175 {
176 ITHACAPOD::getModesSVD(Ufield, Umodes, _U().name(), podex, 0, 0, NU);
177 }
178
179 ITHACAPOD::getModesSVD(Pfield, Pmodes, _p().name(), podex, 0, 0, NP);
180 ITHACAPOD::getModesSVD(Fluxfield, Fluxmodes, _flux().name(), podex, 0, 0, NF);
181 ITHACAPOD::getModesSVD(Prec1field, Prec1modes, _prec1().name(), podex, 0, 0,
182 NPrec1);
183 ITHACAPOD::getModesSVD(Prec2field, Prec2modes, _prec2().name(), podex, 0, 0,
184 NPrec2);
185 ITHACAPOD::getModesSVD(Prec3field, Prec3modes, _prec3().name(), podex, 0, 0,
186 NPrec3);
187 ITHACAPOD::getModesSVD(Prec4field, Prec4modes, _prec4().name(), podex, 0, 0,
188 NPrec4);
189 ITHACAPOD::getModesSVD(Prec5field, Prec5modes, _prec5().name(), podex, 0, 0,
190 NPrec5);
191 ITHACAPOD::getModesSVD(Prec6field, Prec6modes, _prec6().name(), podex, 0, 0,
192 NPrec6);
193 ITHACAPOD::getModesSVD(Prec7field, Prec7modes, _prec7().name(), podex, 0, 0,
194 NPrec7);
195 ITHACAPOD::getModesSVD(Prec8field, Prec8modes, _prec8().name(), podex, 0, 0,
196 NPrec8);
197
198 if (homboolT == true)
199 {
200 ITHACAPOD::getModesSVD(Tomfield, Tmodes, _T().name(), podex, 0, 0, NT);
201 }
202 else
203 {
204 ITHACAPOD::getModesSVD(Tfield, Tmodes, _T().name(), podex, 0, 0, NT);
205 }
206
207 ITHACAPOD::getModesSVD(Dec1field, Dec1modes, _dec1().name(), podex, 0, 0,
208 NDec1);
209 ITHACAPOD::getModesSVD(Dec2field, Dec2modes, _dec2().name(), podex, 0, 0,
210 NDec2);
211 ITHACAPOD::getModesSVD(Dec3field, Dec3modes, _dec3().name(), podex, 0, 0,
212 NDec3);
213 ITHACAPOD::getModesSVD(vFields, vmodes, _v().name(), podex, 0, 0, NC);
214 ITHACAPOD::getModesSVD(DFields, Dmodes, _D().name(), podex, 0, 0, NC);
215 ITHACAPOD::getModesSVD(NSFFields, NSFmodes, _NSF().name(), podex, 0, 0, NC);
216 ITHACAPOD::getModesSVD(AFields, Amodes, _A().name(), podex, 0, 0, NC);
217 ITHACAPOD::getModesSVD(SPFields, SPmodes, _SP().name(), podex, 0, 0, NC);
218 ITHACAPOD::getModesSVD(TXSFields, TXSmodes, _TXS().name(), podex, 0, 0, NC);
219 Info << "End\n" << endl;
220}
221
222// Get the modes function Compliance matrix method
223void msrProblem::msrgetModesEVD()
224{
225 label NU = para->ITHACAdict->lookupOrDefault<label>("NUout", 10);
226 label NP = para->ITHACAdict->lookupOrDefault<label>("NPout", 10);
227 label NF = para->ITHACAdict->lookupOrDefault<label>("NFluxout", 10);
228 label NPrec1 = para->ITHACAdict->lookupOrDefault<label>("NPrecout1", 10);
229 label NPrec2 = para->ITHACAdict->lookupOrDefault<label>("NPrecout2", 10);
230 label NPrec3 = para->ITHACAdict->lookupOrDefault<label>("NPrecout3", 10);
231 label NPrec4 = para->ITHACAdict->lookupOrDefault<label>("NPrecout4", 10);
232 label NPrec5 = para->ITHACAdict->lookupOrDefault<label>("NPrecout5", 10);
233 label NPrec6 = para->ITHACAdict->lookupOrDefault<label>("NPrecout6", 10);
234 label NPrec7 = para->ITHACAdict->lookupOrDefault<label>("NPrecout7", 10);
235 label NPrec8 = para->ITHACAdict->lookupOrDefault<label>("NPrecout8", 10);
236 label NT = para->ITHACAdict->lookupOrDefault<label>("NTout", 10);
237 label NDec1 = para->ITHACAdict->lookupOrDefault<label>("NDecout1", 10);
238 label NDec2 = para->ITHACAdict->lookupOrDefault<label>("NDecout2", 10);
239 label NDec3 = para->ITHACAdict->lookupOrDefault<label>("NDecout3", 10);
240 label NC = para->ITHACAdict->lookupOrDefault<label>("NCout", 10);
241
242 if (homboolU == true)
243 {
244 ITHACAPOD::getModes(Uomfield, Umodes, _U().name(), podex, 0, 0, NU);
245 }
246 else
247 {
248 ITHACAPOD::getModes(Ufield, Umodes, _U().name(), podex, 0, 0, NU);
249 }
250
251 ITHACAPOD::getModes(Pfield, Pmodes, _U().name(), podex, 0, 0, NP);
252 ITHACAPOD::getModes(Fluxfield, Fluxmodes, _U().name(), podex, 0, 0, NF);
253 ITHACAPOD::getModes(Prec1field, Prec1modes, _prec1().name(), podex, 0, 0,
254 NPrec1);
255 ITHACAPOD::getModes(Prec2field, Prec2modes, _prec2().name(), podex, 0, 0,
256 NPrec2);
257 ITHACAPOD::getModes(Prec3field, Prec3modes, _prec3().name(), podex, 0, 0,
258 NPrec3);
259 ITHACAPOD::getModes(Prec4field, Prec4modes, _prec4().name(), podex, 0, 0,
260 NPrec4);
261 ITHACAPOD::getModes(Prec5field, Prec5modes, _prec5().name(), podex, 0, 0,
262 NPrec5);
263 ITHACAPOD::getModes(Prec6field, Prec6modes, _prec6().name(), podex, 0, 0,
264 NPrec6);
265 ITHACAPOD::getModes(Prec7field, Prec7modes, _prec7().name(), podex, 0, 0,
266 NPrec7);
267 ITHACAPOD::getModes(Prec8field, Prec8modes, _prec8().name(), podex, 0, 0,
268 NPrec8);
269
270 if (homboolT == true)
271 {
272 ITHACAPOD::getModes(Tomfield, Tmodes, _T().name(), podex, 0, 0, NT);
273 }
274 else
275 {
276 ITHACAPOD::getModes(Tfield, Tmodes, _T().name(), podex, 0, 0, NT);
277 }
278
279 ITHACAPOD::getModes(Dec1field, Dec1modes, _dec1().name(), podex, 0, 0, NDec1);
280 ITHACAPOD::getModes(Dec2field, Dec2modes, _dec2().name(), podex, 0, 0, NDec2);
281 ITHACAPOD::getModes(Dec3field, Dec3modes, _dec3().name(), podex, 0, 0, NDec3);
282 ITHACAPOD::getModes(vFields, vmodes, _v().name(), podex, 0, 0, NC);
283 ITHACAPOD::getModes(DFields, Dmodes, _D().name(), podex, 0, 0, NC);
284 ITHACAPOD::getModes(NSFFields, NSFmodes, _NSF().name(), podex, 0, 0, NC);
285 ITHACAPOD::getModes(AFields, Amodes, _A().name(), podex, 0, 0, NC);
286 ITHACAPOD::getModes(SPFields, SPmodes, _SP().name(), podex, 0, 0, NC);
287 ITHACAPOD::getModes(TXSFields, TXSmodes, _TXS().name(), podex, 0, 0, NC);
288 Info << "End\n" << endl;
289}
290
291void msrProblem::liftSolve()
292{
293 for (label k = 0; k < inletIndex.rows(); k++)
294 {
295 Time& runTime = _runTime();
296 surfaceScalarField& phi = _phi();
297 fvMesh& mesh = _mesh();
298 volScalarField p = _p();
299 volVectorField U = _U();
300 IOMRFZoneList& MRF = _MRF();
301 label BCind = inletIndex(k, 0);
302 volVectorField Ulift("Ulift" + name(k), U);
303 instantList Times = runTime.times();
304 runTime.setTime(Times[1], 1);
305 pisoControl potentialFlow(mesh, "potentialFlow");
306 Info << "Solving a lifting Problem" << endl;
307 Vector<double> v1(0, 0, 0);
308 v1[inletIndex(k, 1)] = 1;
309 Vector<double> v0(0, 0, 0);
310
311 for (label j = 0; j < U.boundaryField().size(); j++)
312 {
313 if (j == BCind)
314 {
315 assignBC(Ulift, j, v1);
316 }
317 else if (U.boundaryField()[BCind].type() == "fixedValue")
318 {
319 assignBC(Ulift, j, v0);
320 }
321 else
322 {
323 }
324
325 assignIF(Ulift, v0);
326 phi = linearInterpolate(Ulift) & mesh.Sf();
327 }
328
329 Info << "Constructing velocity potential field Phi\n" << endl;
330 volScalarField Phi
331 (
332 IOobject
333 (
334 "Phi",
335 runTime.timeName(),
336 mesh,
337 IOobject::READ_IF_PRESENT,
338 IOobject::NO_WRITE
339 ),
340 mesh,
341 dimensionedScalar("Phi", dimLength * dimVelocity, 0),
342 p.boundaryField().types()
343 );
344 label PhiRefCell = 0;
345 scalar PhiRefValue = 0;
346 setRefCell
347 (
348 Phi,
349 potentialFlow.dict(),
350 PhiRefCell,
351 PhiRefValue
352 );
353 mesh.setFluxRequired(Phi.name());
354 runTime.functionObjects().start();
355 MRF.makeRelative(phi);
356 adjustPhi(phi, Ulift, p);
357
358 while (potentialFlow.correctNonOrthogonal())
359 {
360 fvScalarMatrix PhiEqn
361 (
362 fvm::laplacian(dimensionedScalar("1", dimless, 1), Phi)
363 ==
364 fvc::div(phi)
365 );
366 PhiEqn.setReference(PhiRefCell, PhiRefValue);
367 PhiEqn.solve();
368
369 if (potentialFlow.finalNonOrthogonalIter())
370 {
371 phi -= PhiEqn.flux();
372 }
373 }
374
375 MRF.makeAbsolute(phi);
376 Info << "Continuity error = "
377 << mag(fvc::div(phi))().weightedAverage(mesh.V()).value()
378 << endl;
379 Ulift = fvc::reconstruct(phi);
380 Ulift.correctBoundaryConditions();
381 Info << "Interpolated velocity error = "
382 << (sqrt(sum(sqr((fvc::interpolate(U) & mesh.Sf()) - phi)))
383 / sum(mesh.magSf())).value()
384 << endl;
385 Ulift.write();
386 liftfield.append(Ulift.clone());
387 }
388}
389
390
391
392
393// * * * * * * * * * * * * * * Projection Methods * * * * * * * * * * * * * * //
394
395void msrProblem::projectPPE(fileName folder, label NU, label NP, label NF,
396 Eigen::VectorXi NPrec, label NT, Eigen::VectorXi NDec, label NC)
397{
398 if (NPrec.size() != 8 || NDec.size() != 3)
399 {
400 Info <<
401 "The model assumes 8 groups of precursors and 3 of decay heat, check NDrec and NDec dimensions..."
402 << endl;
403 exit(0);
404 }
405
406 NUmodes = NU;
407 NPmodes = NP;
408 NFluxmodes = NF;
409 NPrecmodes = NPrec;
410 label NPrec1 = NPrecmodes(0);
411 label NPrec2 = NPrecmodes(1);
412 label NPrec3 = NPrecmodes(2);
413 label NPrec4 = NPrecmodes(3);
414 label NPrec5 = NPrecmodes(4);
415 label NPrec6 = NPrecmodes(5);
416 label NPrec7 = NPrecmodes(6);
417 label NPrec8 = NPrecmodes(7);
418 NTmodes = NT;
419 NDecmodes = NDec;
420 label NDec1 = NDecmodes(0);
421 label NDec2 = NDecmodes(1);
422 label NDec3 = NDecmodes(2);
423 NCmodes = NC;
424 Info << "\n Computing fluid-dynamics matrices\n" << endl;
425 B_matrix = diffusive_term(NUmodes, NPmodes);
426 C_matrix = convective_term(NUmodes, NPmodes);
427 M_matrix = mass_term(NUmodes, NPmodes);
428 K_matrix = pressure_gradient_term(NUmodes, NPmodes);
429 D_matrix = laplacian_pressure(NPmodes);
430 G_matrix = div_momentum(NUmodes, NPmodes);
431 BC1_matrix = pressure_BC1(NUmodes, NPmodes);
432 BC2_matrix = pressure_BC2(NUmodes, NPmodes);
433 BC3_matrix = pressure_BC3(NUmodes, NPmodes);
434 Info << "\n End \n" << endl;
435 Info << "\n Computing neutronics matrices\n" << endl;
436 LF_matrix = laplacian_flux(NFluxmodes, NCmodes);
437 MF_matrix = mass_flux(NFluxmodes);
438 PF_matrix = prod_flux(NFluxmodes, NCmodes);
439 AF_matrix = abs_flux(NFluxmodes, NCmodes);
440 PS1_matrix = prec_source(NFluxmodes, NPrec1, 1);
441 PS2_matrix = prec_source(NFluxmodes, NPrec2, 2);
442 PS3_matrix = prec_source(NFluxmodes, NPrec3, 3);
443 PS4_matrix = prec_source(NFluxmodes, NPrec4, 4);
444 PS5_matrix = prec_source(NFluxmodes, NPrec5, 5);
445 PS6_matrix = prec_source(NFluxmodes, NPrec6, 6);
446 PS7_matrix = prec_source(NFluxmodes, NPrec7, 7);
447 PS8_matrix = prec_source(NFluxmodes, NPrec8, 8);
448 ST1_matrix = stream_term(NUmodes, NPrec1, 1);
449 ST2_matrix = stream_term(NUmodes, NPrec2, 2);
450 ST3_matrix = stream_term(NUmodes, NPrec3, 3);
451 ST4_matrix = stream_term(NUmodes, NPrec4, 4);
452 ST5_matrix = stream_term(NUmodes, NPrec5, 5);
453 ST6_matrix = stream_term(NUmodes, NPrec6, 6);
454 ST7_matrix = stream_term(NUmodes, NPrec7, 7);
455 ST8_matrix = stream_term(NUmodes, NPrec8, 8);
456 MP1_matrix = prec_mass(NPrec1, 1);
457 MP2_matrix = prec_mass(NPrec2, 2);
458 MP3_matrix = prec_mass(NPrec3, 3);
459 MP4_matrix = prec_mass(NPrec4, 4);
460 MP5_matrix = prec_mass(NPrec5, 5);
461 MP6_matrix = prec_mass(NPrec6, 6);
462 MP7_matrix = prec_mass(NPrec7, 7);
463 MP8_matrix = prec_mass(NPrec8, 8);
464 LP1_matrix = laplacian_prec(NPrec1, 1);
465 LP2_matrix = laplacian_prec(NPrec2, 2);
466 LP3_matrix = laplacian_prec(NPrec3, 3);
467 LP4_matrix = laplacian_prec(NPrec4, 4);
468 LP5_matrix = laplacian_prec(NPrec5, 5);
469 LP6_matrix = laplacian_prec(NPrec6, 6);
470 LP7_matrix = laplacian_prec(NPrec7, 7);
471 LP8_matrix = laplacian_prec(NPrec8, 8);
472 FS1_matrix = flux_source(NFluxmodes, NPrec1, NCmodes, 1);
473 FS2_matrix = flux_source(NFluxmodes, NPrec2, NCmodes, 2);
474 FS3_matrix = flux_source(NFluxmodes, NPrec3, NCmodes, 3);
475 FS4_matrix = flux_source(NFluxmodes, NPrec4, NCmodes, 4);
476 FS5_matrix = flux_source(NFluxmodes, NPrec5, NCmodes, 5);
477 FS6_matrix = flux_source(NFluxmodes, NPrec6, NCmodes, 6);
478 FS7_matrix = flux_source(NFluxmodes, NPrec7, NCmodes, 7);
479 FS8_matrix = flux_source(NFluxmodes, NPrec8, NCmodes, 8);
480 Info << "\n End \n" << endl;
481 Info << "\n Computing thermal matrices\n" << endl;
482 SD1_matrix = stream_dec(NUmodes, NDec1, 1);
483 SD2_matrix = stream_dec(NUmodes, NDec2, 2);
484 SD3_matrix = stream_dec(NUmodes, NDec3, 3);
485 MD1_matrix = dec_mass(NDec1, 1);
486 MD2_matrix = dec_mass(NDec2, 2);
487 MD3_matrix = dec_mass(NDec3, 3);
488 LD1_matrix = laplacian_dec(NDec1, 1);
489 LD2_matrix = laplacian_dec(NDec2, 2);
490 LD3_matrix = laplacian_dec(NDec3, 3);
491 DFS1_matrix = dec_fluxsource(NFluxmodes, NDec1, NCmodes, 1);
492 DFS2_matrix = dec_fluxsource(NFluxmodes, NDec2, NCmodes, 2);
493 DFS3_matrix = dec_fluxsource(NFluxmodes, NDec3, NCmodes, 3);
494 TM_matrix = mass_temp(NTmodes);
495 TS_matrix = temp_stream(NUmodes, NTmodes);
496 LT_matrix = laplacian_temp(NTmodes);
497 TXS_matrix = temp_XSfluxsource(NTmodes, NFluxmodes, NCmodes);
498 THS1_matrix = temp_heatsource(NTmodes, NDec1, NCmodes, 1);
499 THS2_matrix = temp_heatsource(NTmodes, NDec2, NCmodes, 2);
500 THS3_matrix = temp_heatsource(NTmodes, NDec3, NCmodes, 3);
501 Info << "\n End \n" << endl;
502 msrcoeff(NCmodes);
503}
504
505// * * * * * * * * * * * * * * Momentum Eq. Methods * * * * * * * * * * * * * //
506
507Eigen::MatrixXd msrProblem::diffusive_term(label NUmodes, label NPmodes)
508{
509 label Bsize = NUmodes + liftfield.size();
510 Eigen::MatrixXd B_matrix;
511 B_matrix.resize(Bsize, Bsize);
512 PtrList<volVectorField> Together(0);
513
514 if (liftfield.size() != 0)
515 {
516 for (label k = 0; k < liftfield.size(); k++)
517 {
518 Together.append(liftfield[k].clone());
519 }
520 }
521
522 if (NUmodes != 0)
523 {
524 for (label k = 0; k < NUmodes; k++)
525 {
526 Together.append(Umodes[k].clone());
527 }
528 }
529
530 // Project everything
531 for (label i = 0; i < Bsize; i++)
532 {
533 for (label j = 0; j < Bsize; j++)
534 {
535 B_matrix(i, j) = fvc::domainIntegrate(Together[i] & fvc::laplacian(
536 dimensionedScalar("1", dimless, 1), Together[j])).value();
537 }
538 }
539
540 // Export the matrix
541 ITHACAstream::exportMatrix(B_matrix, "B", "matlab",
542 "./ITHACAoutput/Matrices/fluid_dynamics/");
543 return B_matrix;
544}
545
546Eigen::MatrixXd msrProblem::pressure_gradient_term(label NUmodes, label NPmodes)
547{
548 label K1size = NUmodes + liftfield.size();
549 label K2size = NPmodes;
550 Eigen::MatrixXd K_matrix(K1size, K2size);
551 PtrList<volVectorField> Together(0);
552
553 if (liftfield.size() != 0)
554 {
555 for (label k = 0; k < liftfield.size(); k++)
556 {
557 Together.append(liftfield[k].clone());
558 }
559 }
560
561 if (NUmodes != 0)
562 {
563 for (label k = 0; k < NUmodes; k++)
564 {
565 Together.append(Umodes[k].clone());
566 }
567 }
568
569 // Project everything
570 for (label i = 0; i < K1size; i++)
571 {
572 for (label j = 0; j < K2size; j++)
573 {
574 K_matrix(i, j) = fvc::domainIntegrate(Together[i] & fvc::grad(
575 Pmodes[j])).value();
576 }
577 }
578
579 // Export the matrix
580 ITHACAstream::exportMatrix(K_matrix, "K", "matlab",
581 "./ITHACAoutput/Matrices/fluid_dynamics/");
582 return K_matrix;
583}
584
585List <Eigen::MatrixXd> msrProblem::convective_term(label NUmodes,
586 label NPmodes)
587{
588 label Csize = NUmodes + liftfield.size();
589 List <Eigen::MatrixXd> C_matrix;
590 C_matrix.setSize(Csize);
591
592 for (label j = 0; j < Csize; j++)
593 {
594 C_matrix[j].resize(Csize, Csize);
595 }
596
597 PtrList<volVectorField> Together(0);
598
599 if (liftfield.size() != 0)
600 {
601 for (label k = 0; k < liftfield.size(); k++)
602 {
603 Together.append(liftfield[k].clone());
604 }
605 }
606
607 if (NUmodes != 0)
608 {
609 for (label k = 0; k < NUmodes; k++)
610 {
611 Together.append(Umodes[k].clone());
612 }
613 }
614
615 for (label i = 0; i < Csize; i++)
616 {
617 for (label j = 0; j < Csize; j++)
618 {
619 for (label k = 0; k < Csize; k++)
620 {
621 C_matrix[i](j, k) = fvc::domainIntegrate(Together[i] & fvc::div(
622 linearInterpolate(Together[j]) & Together[j].mesh().Sf(), Together[k])).value();
623 }
624 }
625 }
626
627 // Export the matrix
628 ITHACAstream::exportMatrix(C_matrix, "C", "matlab",
629 "./ITHACAoutput/Matrices/fluid_dynamics/");
630 return C_matrix;
631}
632
633Eigen::MatrixXd msrProblem::mass_term(label NUmodes, label NPmodes)
634{
635 label Msize = NUmodes + liftfield.size();
636 Eigen::MatrixXd M_matrix(Msize, Msize);
637 PtrList<volVectorField> Together(0);
638
639 if (liftfield.size() != 0)
640 {
641 for (label k = 0; k < liftfield.size(); k++)
642 {
643 Together.append(liftfield[k].clone());
644 }
645 }
646
647 if (NUmodes != 0)
648 {
649 for (label k = 0; k < NUmodes; k++)
650 {
651 Together.append(Umodes[k].clone());
652 }
653 }
654
655 // Project everything
656 for (label i = 0; i < Msize; i++)
657 {
658 for (label j = 0; j < Msize; j++)
659 {
660 M_matrix(i, j) = fvc::domainIntegrate(Together[i] & Together[j]).value();
661 }
662 }
663
664 // Export the matrix
665 ITHACAstream::exportMatrix(M_matrix, "M", "matlab",
666 "./ITHACAoutput/Matrices/fluid_dynamics/");
667 return M_matrix;
668}
669
670// * * * * * * * * * * * * * * Continuity Eq. Methods * * * * * * * * * * * * * //
671
672Eigen::MatrixXd msrProblem::divergence_term(label NUmodes, label NPmodes)
673{
674 label P1size = NPmodes;
675 label P2size = NUmodes + liftfield.size();
676 Eigen::MatrixXd P_matrix(P1size, P2size);
677 PtrList<volVectorField> Together(0);
678
679 if (liftfield.size() != 0)
680 {
681 for (label k = 0; k < liftfield.size(); k++)
682 {
683 Together.append(liftfield[k].clone());
684 }
685 }
686
687 if (NUmodes != 0)
688 {
689 for (label k = 0; k < NUmodes; k++)
690 {
691 Together.append(Umodes[k].clone());
692 }
693 }
694
695 // Project everything
696 for (label i = 0; i < P1size; i++)
697 {
698 for (label j = 0; j < P2size; j++)
699 {
700 P_matrix(i, j) = fvc::domainIntegrate(Pmodes[i] * fvc::div (
701 Together[j])).value();
702 }
703 }
704
705 //Export the matrix
706 ITHACAstream::exportMatrix(P_matrix, "P", "matlab",
707 "./ITHACAoutput/Matrices/fluid_dynamics/");
708 return P_matrix;
709}
710
711
712List <Eigen::MatrixXd> msrProblem::div_momentum(label NUmodes, label NPmodes)
713{
714 label G1size = NPmodes;
715 label G2size = NUmodes + liftfield.size();
716 List <Eigen::MatrixXd> G_matrix;
717 G_matrix.setSize(G1size);
718
719 for (label j = 0; j < G1size; j++)
720 {
721 G_matrix[j].resize(G2size, G2size);
722 }
723
724 PtrList<volVectorField> Together(0);
725
726 if (liftfield.size() != 0)
727 {
728 for (label k = 0; k < liftfield.size(); k++)
729 {
730 Together.append(liftfield[k].clone());
731 }
732 }
733
734 if (NUmodes != 0)
735 {
736 for (label k = 0; k < NUmodes; k++)
737 {
738 Together.append(Umodes[k].clone());
739 }
740 }
741
742 for (label i = 0; i < G1size; i++)
743 {
744 for (label j = 0; j < G2size; j++)
745 {
746 for (label k = 0; k < G2size; k++)
747 {
748 G_matrix[i](j, k) = fvc::domainIntegrate(fvc::grad(Pmodes[i]) & (fvc::div(
749 fvc::interpolate(Together[j]) & Together[j].mesh().Sf(), Together[k]))).value();
750 }
751 }
752 }
753
754 // Export the matrix
755 ITHACAstream::exportMatrix(G_matrix, "G", "matlab",
756 "./ITHACAoutput/Matrices/fluid_dynamics/");
757 return G_matrix;
758}
759
760Eigen::MatrixXd msrProblem::laplacian_pressure(label NPmodes)
761{
762 label Dsize = NPmodes;
763 Eigen::MatrixXd D_matrix(Dsize, Dsize);
764
765 // Project everything
766 for (label i = 0; i < Dsize; i++)
767 {
768 for (label j = 0; j < Dsize; j++)
769 {
770 D_matrix(i, j) = fvc::domainIntegrate(fvc::grad(Pmodes[i]) & fvc::grad(
771 Pmodes[j])).value();
772 }
773 }
774
775 //Export the matrix
776 ITHACAstream::exportMatrix(D_matrix, "D", "matlab",
777 "./ITHACAoutput/Matrices/fluid_dynamics/");
778 return D_matrix;
779}
780
781Eigen::MatrixXd msrProblem::pressure_BC1(label NUmodes, label NPmodes)
782{
783 label P_BC1size = NPmodes;
784 label P_BC2size = NUmodes + liftfield.size();
785 Eigen::MatrixXd BC1_matrix(P_BC1size, P_BC2size);
786 fvMesh& mesh = _mesh();
787 PtrList<volVectorField> Together(0);
788
789 if (liftfield.size() != 0)
790 {
791 for (label k = 0; k < liftfield.size(); k++)
792 {
793 Together.append(liftfield[k].clone());
794 }
795 }
796
797 if (NUmodes != 0)
798 {
799 for (label k = 0; k < NUmodes; k++)
800 {
801 Together.append(Umodes[k].clone());
802 }
803 }
804
805 for (label i = 0; i < P_BC1size; i++)
806 {
807 for (label j = 0; j < P_BC2size; j++)
808 {
809 surfaceScalarField lpl((fvc::interpolate(fvc::laplacian(
810 Together[j])) & mesh.Sf()) * fvc::interpolate(Pmodes[i]));
811 double s = 0;
812
813 for (label k = 0; k < lpl.boundaryField().size(); k++)
814 {
815 s += gSum(lpl.boundaryField()[k]);
816 }
817
818 BC1_matrix(i, j) = s;
819 }
820 }
821
822 ITHACAstream::exportMatrix(BC1_matrix, "BC1", "matlab",
823 "./ITHACAoutput/Matrices/fluid_dynamics/");
824 return BC1_matrix;
825}
826
827
828List <Eigen::MatrixXd> msrProblem::pressure_BC2(label NUmodes, label NPmodes)
829{
830 label P2_BC1size = NPmodes;
831 label P2_BC2size = NUmodes + liftfield.size();
832 List <Eigen::MatrixXd> BC2_matrix;
833 fvMesh& mesh = _mesh();
834 BC2_matrix.setSize(P2_BC1size);
835
836 for (label j = 0; j < P2_BC1size; j++)
837 {
838 BC2_matrix[j].resize(P2_BC2size, P2_BC2size);
839 }
840
841 PtrList<volVectorField> Together(0);
842
843 if (liftfield.size() != 0)
844 {
845 for (label k = 0; k < liftfield.size(); k++)
846 {
847 Together.append(liftfield[k].clone());
848 }
849 }
850
851 if (NUmodes != 0)
852 {
853 for (label k = 0; k < NUmodes; k++)
854 {
855 Together.append(Umodes[k].clone());
856 }
857 }
858
859 for (label i = 0; i < P2_BC1size; i++)
860 {
861 for (label j = 0; j < P2_BC2size; j++)
862 {
863 for (label k = 0; k < P2_BC2size; k++)
864 {
865 surfaceScalarField div_m(fvc::interpolate(fvc::div(fvc::interpolate(
866 Together[j]) & mesh.Sf(),
867 Together[k])) & mesh.Sf() * fvc::interpolate(Pmodes[i]));
868 double s = 0;
869
870 for (label k = 0; k < div_m.boundaryField().size(); k++)
871 {
872 s += gSum(div_m.boundaryField()[k]);
873 }
874
875 BC2_matrix[i](j, k) = s;
876 }
877 }
878 }
879
880 // Export the matrix
881 ITHACAstream::exportMatrix(BC2_matrix, "BC2", "matlab",
882 "./ITHACAoutput/Matrices/fluid_dynamics/");
883 return BC2_matrix;
884}
885
886Eigen::MatrixXd msrProblem::pressure_BC3(label NUmodes, label NPmodes)
887{
888 label P3_BC1size = NPmodes;
889 label P3_BC2size = NUmodes + liftfield.size();
890 Eigen::MatrixXd BC3_matrix(P3_BC1size, P3_BC2size);
891 fvMesh& mesh = _mesh();
892 PtrList<volVectorField> Together(0);
893
894 if (liftfield.size() != 0)
895 {
896 for (label k = 0; k < liftfield.size(); k++)
897 {
898 Together.append(liftfield[k].clone());
899 }
900 }
901
902 if (NUmodes != 0)
903 {
904 for (label k = 0; k < NUmodes; k++)
905 {
906 Together.append(Umodes[k].clone());
907 }
908 }
909
910 surfaceVectorField n(mesh.Sf() / mesh.magSf());
911
912 for (label i = 0; i < P3_BC1size; i++)
913 {
914 for (label j = 0; j < P3_BC2size; j++)
915 {
916 surfaceVectorField BC3 = fvc::interpolate(fvc::curl(Together[j])).ref();
917 surfaceVectorField BC4 = (n ^ fvc::interpolate(fvc::grad(Pmodes[i]))).ref();
918 surfaceScalarField BC5 = ((BC3 & BC4) * mesh.magSf()).ref();
919 double s = 0;
920
921 for (label k = 0; k < BC5.boundaryField().size(); k++)
922 {
923 s += gSum(BC5.boundaryField()[k]);
924 }
925
926 BC3_matrix(i, j) = s;
927 }
928 }
929
930 ITHACAstream::exportMatrix(BC3_matrix, "BC3", "matlab",
931 "./ITHACAoutput/Matrices/fluid_dynamics/");
932 return BC3_matrix;
933}
934
935
936// * * * * * * * * * * * * * * Diffusion Eq. Methods * * * * * * * * * * * * * //
937
938List<Eigen::MatrixXd> msrProblem::laplacian_flux(label NFluxmodes,
939 label NCmodes)
940{
941 label LFsize = NFluxmodes;
942 List<Eigen::MatrixXd> LF_matrix;
943 LF_matrix.setSize(LFsize);
944
945 for (label j = 0; j < LFsize; j++)
946 {
947 LF_matrix[j].resize(NCmodes, LFsize);
948 LF_matrix[j].setZero();
949 }
950
951 // Project everything
952 for (label i = 0; i < LFsize; i++)
953 {
954 for (label j = 0; j < NCmodes; j++)
955 {
956 for (label k = 0; k < LFsize; k++)
957 {
958 LF_matrix[i](j, k) = fvc::domainIntegrate(Fluxmodes[i] * fvc::laplacian(
959 Dmodes[j], Fluxmodes[k])).value();
960 }
961 }
962 }
963
964 // Export the matrix
965 ITHACAstream::exportMatrix(LF_matrix, "LF", "matlab",
966 "./ITHACAoutput/Matrices/neutronics/");
967 return LF_matrix;
968}
969
970Eigen::MatrixXd msrProblem::mass_flux(label NFluxmodes)
971{
972 label MFsize = NFluxmodes;
973 Eigen::MatrixXd MF_matrix;
974 MF_matrix.resize(MFsize, MFsize);
975
976 // Project everything
977 for (label i = 0; i < MFsize; i++)
978 {
979 for (label j = 0; j < MFsize; j++)
980 {
981 MF_matrix(i, j) = fvc::domainIntegrate(Fluxmodes[i] * Fluxmodes[j]).value();
982 }
983 }
984
985 // Export the matrix
986 ITHACAstream::exportMatrix(MF_matrix, "MF", "matlab",
987 "./ITHACAoutput/Matrices/neutronics/");
988 return MF_matrix;
989}
990
991List<Eigen::MatrixXd> msrProblem::prod_flux(label NFluxmodes, label NCmodes)
992{
993 label PFsize = NFluxmodes;
994 List<Eigen::MatrixXd> PF_matrix;
995 PF_matrix.setSize(PFsize);
996
997 for (label j = 0; j < PFsize; j++)
998 {
999 PF_matrix[j].resize(NCmodes, PFsize);
1000 PF_matrix[j].setZero();
1001 }
1002
1003 //Project everything
1004 for (label i = 0; i < PFsize; i++)
1005 {
1006 for (label j = 0; j < NCmodes; j++)
1007 {
1008 for (label k = 0; k < PFsize; k++)
1009 {
1010 PF_matrix[i](j, k) = fvc::domainIntegrate(Fluxmodes[i] * NSFmodes[j] *
1011 Fluxmodes[k]).value();
1012 }
1013 }
1014 }
1015
1016 // Export the matrix
1017 ITHACAstream::exportMatrix(PF_matrix, "PF", "matlab",
1018 "./ITHACAoutput/Matrices/neutronics/");
1019 return PF_matrix;
1020}
1021
1022List<Eigen::MatrixXd> msrProblem::abs_flux(label NFluxmodes, label NCmodes)
1023{
1024 label AFsize = NFluxmodes;
1025 List<Eigen::MatrixXd> AF_matrix;
1026 AF_matrix.setSize(AFsize);
1027
1028 for (label j = 0; j < AFsize; j++)
1029 {
1030 AF_matrix[j].resize(NCmodes, AFsize);
1031 AF_matrix[j].setZero();
1032 }
1033
1034 //Project everything
1035 for (label i = 0; i < AFsize; i++)
1036 {
1037 for (label j = 0; j < NCmodes; j++)
1038 {
1039 for (label k = 0; k < AFsize; k++)
1040 {
1041 AF_matrix[i](j, k) = fvc::domainIntegrate(Fluxmodes[i] * Amodes[j] *
1042 Fluxmodes[k]).value();
1043 }
1044 }
1045 }
1046
1047 // Export the matrix
1048 ITHACAstream::exportMatrix(AF_matrix, "AF", "matlab",
1049 "./ITHACAoutput/Matrices/neutronics/");
1050 return AF_matrix;
1051}
1052
1053Eigen::MatrixXd msrProblem::prec_source(label NFluxmodes, label NPrecmodes,
1054 label family)
1055{
1056 label p = family;
1057 PtrList<volScalarField> Precmodes = choose_group("prec", p);
1058 label PS1size = NFluxmodes;
1059 label PS2size = NPrecmodes;
1060 Eigen::MatrixXd PS_matrix;
1061 PS_matrix.resize(PS1size, PS2size);
1062
1063 // Project everything
1064 for (label i = 0; i < PS1size; i++)
1065 {
1066 for (label j = 0; j < PS2size; j++)
1067 {
1068 PS_matrix(i, j) = fvc::domainIntegrate(Fluxmodes[i] * Precmodes[j]).value();
1069 }
1070 }
1071
1072 savegroupMatrix("PS", p, "./ITHACAoutput/Matrices/neutronics/", PS_matrix);
1073 return PS_matrix;
1074}
1075
1076// * * * * * * * * * * * * * * Precursor Eq. Methods * * * * * * * * * * * * * //
1077
1078List<Eigen::MatrixXd> msrProblem::stream_term(label NUmodes, label NPrecmodes,
1079 label family)
1080{
1081 label p = family;
1082 PtrList<volScalarField> Precmodes = choose_group("prec", p);
1083 label ST1size = NPrecmodes; //Qsizet
1084 label ST2size = NUmodes + liftfield.size();
1085 List<Eigen::MatrixXd> ST_matrix;
1086 ST_matrix.setSize(ST1size);
1087
1088 for (label j = 0; j < ST1size; j++)
1089 {
1090 ST_matrix[j].resize(ST2size, ST1size);
1091 ST_matrix[j].setZero();
1092 }
1093
1094 PtrList<volVectorField> Together(0);
1095
1096 if (liftfield.size() != 0)
1097 {
1098 for (label k = 0; k < liftfield.size(); k++)
1099 {
1100 Together.append(liftfield[k].clone());
1101 }
1102 }
1103
1104 if (NUmodes != 0)
1105 {
1106 for (label k = 0; k < NUmodes; k++)
1107 {
1108 Together.append(Umodes[k].clone());
1109 }
1110 }
1111
1112 // Project everything
1113 for (label i = 0; i < ST1size; i++)
1114 {
1115 for (label j = 0; j < ST2size; j++)
1116 {
1117 for (label k = 0; k < ST1size; k++)
1118 {
1119 ST_matrix[i](j, k) = fvc::domainIntegrate(Precmodes[i] * fvc::div(
1120 fvc::interpolate(Together[j]) & Together[j].mesh().Sf(), Precmodes[k])).value();
1121 }
1122 }
1123 }
1124
1125 savegroupMatrix("ST", p, "./ITHACAoutput/Matrices/neutronics/", ST_matrix);
1126 return ST_matrix;
1127}
1128
1129Eigen::MatrixXd msrProblem::prec_mass(label NPrecmodes, label family)
1130{
1131 label p = family;
1132 PtrList<volScalarField> Precmodes = choose_group("prec", p);
1133 label MPsize = NPrecmodes;
1134 Eigen::MatrixXd MP_matrix;
1135 MP_matrix.resize(MPsize, MPsize);
1136
1137 // Project everything
1138 for (label i = 0; i < MPsize; i++)
1139 {
1140 for (label j = 0; j < MPsize; j++)
1141 {
1142 MP_matrix(i, j) = fvc::domainIntegrate(Precmodes[i] * Precmodes[j]).value();
1143 }
1144 }
1145
1146 savegroupMatrix("MP", p, "./ITHACAoutput/Matrices/neutronics/", MP_matrix);
1147 return MP_matrix;
1148}
1149
1150Eigen::MatrixXd msrProblem::laplacian_prec(label NPrecmodes, label family)
1151{
1152 label p = family;
1153 PtrList<volScalarField> Precmodes = choose_group("prec", p);
1154 label LPsize = NPrecmodes;
1155 Eigen::MatrixXd LP_matrix;
1156 LP_matrix.resize(LPsize, LPsize);
1157
1158 for (label i = 0; i < LPsize; i++)
1159 {
1160 for (label j = 0; j < LPsize; j++)
1161 {
1162 LP_matrix(i, j) = fvc::domainIntegrate(Precmodes[i] * fvc::laplacian(
1163 dimensionedScalar("1", dimless, 1), Precmodes[j])).value();
1164 }
1165 }
1166
1167 savegroupMatrix("LP", p, "./ITHACAoutput/Matrices/neutronics/", LP_matrix);
1168 return LP_matrix;
1169}
1170
1171List<Eigen::MatrixXd> msrProblem::flux_source(label NFluxmodes,
1172 label NPrecmodes, label NCmodes, label family)
1173{
1174 label p = family;
1175 PtrList<volScalarField> Precmodes = choose_group("prec", p);
1176 label FSsize = NPrecmodes;
1177 List<Eigen::MatrixXd> FS_matrix;
1178 FS_matrix.setSize(FSsize);
1179
1180 for (label j = 0; j < FSsize; j++)
1181 {
1182 FS_matrix[j].resize(NCmodes, NFluxmodes);
1183 FS_matrix[j].setZero();
1184 }
1185
1186 // Project everything
1187 for (label i = 0; i < FSsize; i++)
1188 {
1189 for (label j = 0; j < NCmodes; j++)
1190 {
1191 for (label k = 0; k < NFluxmodes; k++)
1192 {
1193 FS_matrix[i](j, k) = fvc::domainIntegrate(Precmodes[i] * NSFmodes[j] *
1194 Fluxmodes[k]).value();
1195 }
1196 }
1197 }
1198
1199 savegroupMatrix("FS", p, "./ITHACAoutput/Matrices/neutronics/", FS_matrix);
1200 return FS_matrix;
1201}
1202
1203
1204
1205// * * * * * * * * * * Decay heat Eq. Methods * * * * * * * * * * * * * //
1206
1207
1208
1209List<Eigen::MatrixXd> msrProblem::stream_dec(label NUmodes, label NDecmodes,
1210 label decgroup)
1211{
1212 label g = decgroup;
1213 PtrList<volScalarField> Decmodes = choose_group("dec", g);
1214 label SD1size = NDecmodes; //Qsizet
1215 label SD2size = NUmodes + liftfield.size();
1216 List<Eigen::MatrixXd> SD_matrix;
1217 SD_matrix.setSize(SD1size);
1218
1219 for (label j = 0; j < SD1size; j++)
1220 {
1221 SD_matrix[j].resize(SD2size, SD1size);
1222 SD_matrix[j].setZero();
1223 }
1224
1225 PtrList<volVectorField> Together(0);
1226
1227 if (liftfield.size() != 0)
1228 {
1229 for (label k = 0; k < liftfield.size(); k++)
1230 {
1231 Together.append(liftfield[k].clone());
1232 }
1233 }
1234
1235 if (NUmodes != 0)
1236 {
1237 for (label k = 0; k < NUmodes; k++)
1238 {
1239 Together.append(Umodes[k].clone());
1240 }
1241 }
1242
1243 // Project everything
1244 for (label i = 0; i < SD1size; i++)
1245 {
1246 for (label j = 0; j < SD2size; j++)
1247 {
1248 for (label k = 0; k < SD1size; k++)
1249 {
1250 SD_matrix[i](j, k) = fvc::domainIntegrate(Decmodes[i] * fvc::div(
1251 fvc::interpolate(Together[j]) & Together[j].mesh().Sf(), Decmodes[k])).value();
1252 }
1253 }
1254 }
1255
1256 savegroupMatrix("SD", g, "./ITHACAoutput/Matrices/thermal/", SD_matrix);
1257 return SD_matrix;
1258}
1259
1260Eigen::MatrixXd msrProblem::dec_mass(label NDecmodes, label decgroup)
1261{
1262 label g = decgroup;
1263 PtrList<volScalarField> Decmodes = choose_group("dec", g);
1264 label MDsize = NDecmodes;
1265 Eigen::MatrixXd MD_matrix;
1266 MD_matrix.resize(MDsize, MDsize);
1267
1268 // Project everything
1269 for (label i = 0; i < MDsize; i++)
1270 {
1271 for (label j = 0; j < MDsize; j++)
1272 {
1273 MD_matrix(i, j) = fvc::domainIntegrate(Decmodes[i] * Decmodes[j]).value();
1274 }
1275 }
1276
1277 savegroupMatrix("MD", g, "./ITHACAoutput/Matrices/thermal/", MD_matrix);
1278 return MD_matrix;
1279}
1280
1281
1282Eigen::MatrixXd msrProblem::laplacian_dec(label NDecmodes, label decgroup)
1283{
1284 label g = decgroup;
1285 PtrList<volScalarField> Decmodes = choose_group("dec", g);
1286 label LDsize = NDecmodes;
1287 Eigen::MatrixXd LD_matrix;
1288 LD_matrix.resize(LDsize, LDsize);
1289
1290 // Project everything
1291 for (label i = 0; i < LDsize; i++)
1292 {
1293 for (label j = 0; j < LDsize; j++)
1294 {
1295 LD_matrix(i, j) = fvc::domainIntegrate(Decmodes[i] * fvc::laplacian(
1296 dimensionedScalar("1", dimless, 1), Decmodes[j])).value();
1297 }
1298 }
1299
1300 savegroupMatrix("LD", g, "./ITHACAoutput/Matrices/thermal/", LD_matrix);
1301 return LD_matrix;
1302}
1303
1304List<Eigen::MatrixXd> msrProblem::dec_fluxsource(label NFluxmodes,
1305 label NDecmodes, label NCmodes, label decgroup)
1306{
1307 label g = decgroup;
1308 PtrList<volScalarField> Decmodes = choose_group("dec", g);
1309 label DFSsize = NDecmodes;
1310 List<Eigen::MatrixXd> DFS_matrix;
1311 DFS_matrix.setSize(DFSsize);
1312
1313 for (label j = 0; j < DFSsize; j++)
1314 {
1315 DFS_matrix[j].resize(NCmodes, NFluxmodes);
1316 DFS_matrix[j].setZero();
1317 }
1318
1319 // Project everything
1320 for (label i = 0; i < DFSsize; i++)
1321 {
1322 for (label j = 0; j < NCmodes; j++)
1323 {
1324 for (label k = 0; k < NFluxmodes; k++)
1325 {
1326 DFS_matrix[i](j, k) = fvc::domainIntegrate(Decmodes[i] * SPmodes[j] *
1327 Fluxmodes[k]).value();
1328 }
1329 }
1330 }
1331
1332 savegroupMatrix("DFS", g, "./ITHACAoutput/Matrices/thermal/", DFS_matrix);
1333 return DFS_matrix;
1334}
1335
1336
1337
1338// * * * * * * * * * * * Temperature Eq. Methods * * * * * * * * * * * * * //
1339
1340Eigen::MatrixXd msrProblem::mass_temp(label NTmodes)
1341{
1342 label TMsize = NTmodes + liftfieldT.size();
1343 Eigen::MatrixXd TM_matrix;
1344 TM_matrix.resize(TMsize, TMsize);
1345 PtrList<volScalarField> TogetherT(0);
1346
1347 if (liftfieldT.size() != 0)
1348 {
1349 for (label k = 0; k < liftfieldT.size(); k++)
1350 {
1351 TogetherT.append(liftfieldT[k].clone());
1352 }
1353 }
1354
1355 if (NTmodes != 0)
1356 {
1357 for (label k = 0; k < NTmodes; k++)
1358 {
1359 TogetherT.append(Tmodes[k].clone());
1360 }
1361 }
1362
1363 // Project everything
1364 for (label i = 0; i < TMsize; i++)
1365 {
1366 for (label j = 0; j < TMsize; j++)
1367 {
1368 TM_matrix(i, j) = fvc::domainIntegrate(TogetherT[i] * TogetherT[j]).value();
1369 }
1370 }
1371
1372 // Export the matrix
1373 ITHACAstream::exportMatrix(TM_matrix, "TM", "matlab",
1374 "./ITHACAoutput/Matrices/thermal/");
1375 return TM_matrix;
1376}
1377
1378List<Eigen::MatrixXd> msrProblem::temp_stream(label NUmodes, label NTmodes)
1379{
1380 label TS1size = NTmodes + liftfieldT.size(); //Qsizet
1381 label TS2size = NUmodes + liftfield.size();
1382 List<Eigen::MatrixXd> TS_matrix;
1383 TS_matrix.setSize(TS1size);
1384
1385 for (label j = 0; j < TS1size; j++)
1386 {
1387 TS_matrix[j].resize(TS2size, TS1size);
1388 TS_matrix[j].setZero();
1389 }
1390
1391 PtrList<volVectorField> Together(0);
1392
1393 if (liftfield.size() != 0)
1394 {
1395 for (label k = 0; k < liftfield.size(); k++)
1396 {
1397 Together.append(liftfield[k].clone());
1398 }
1399 }
1400
1401 if (NUmodes != 0)
1402 {
1403 for (label k = 0; k < NUmodes; k++)
1404 {
1405 Together.append(Umodes[k].clone());
1406 }
1407 }
1408
1409 PtrList<volScalarField> TogetherT(0);
1410
1411 if (liftfieldT.size() != 0)
1412 {
1413 for (label k = 0; k < liftfieldT.size(); k++)
1414 {
1415 TogetherT.append(liftfieldT[k].clone());
1416 }
1417 }
1418
1419 if (NTmodes != 0)
1420 {
1421 for (label k = 0; k < NTmodes; k++)
1422 {
1423 TogetherT.append(Tmodes[k].clone());
1424 }
1425 }
1426
1427 // Project everything
1428 for (label i = 0; i < TS1size; i++)
1429 {
1430 for (label j = 0; j < TS2size; j++)
1431 {
1432 for (label k = 0; k < TS1size; k++)
1433 {
1434 TS_matrix[i](j, k) = fvc::domainIntegrate(TogetherT[i] * fvc::div(
1435 fvc::interpolate(Together[j]) & Together[j].mesh().Sf(), TogetherT[k])).value();
1436 }
1437 }
1438 }
1439
1440 // Export the matrix
1441 ITHACAstream::exportMatrix(TS_matrix, "TS", "matlab",
1442 "./ITHACAoutput/Matrices/thermal/");
1443 return TS_matrix;
1444}
1445
1446
1447Eigen::MatrixXd msrProblem::laplacian_temp(label NTmodes)
1448{
1449 label LTsize = NTmodes + liftfieldT.size();
1450 Eigen::MatrixXd LT_matrix;
1451 LT_matrix.resize(LTsize, LTsize);
1452 PtrList<volScalarField> TogetherT(0);
1453
1454 if (liftfieldT.size() != 0)
1455 {
1456 for (label k = 0; k < liftfieldT.size(); k++)
1457 {
1458 TogetherT.append(liftfieldT[k].clone());
1459 }
1460 }
1461
1462 if (NTmodes != 0)
1463 {
1464 for (label k = 0; k < NTmodes; k++)
1465 {
1466 TogetherT.append(Tmodes[k].clone());
1467 }
1468 }
1469
1470 // Project everything
1471 for (label i = 0; i < LTsize; i++)
1472 {
1473 for (label j = 0; j < LTsize; j++)
1474 {
1475 LT_matrix(i, j) = fvc::domainIntegrate(TogetherT[i] * fvc::laplacian(
1476 dimensionedScalar("1", dimless, 1), TogetherT[j])).value();
1477 }
1478 }
1479
1480 // Export the matrix
1481 ITHACAstream::exportMatrix(LT_matrix, "LT", "matlab",
1482 "./ITHACAoutput/Matrices/thermal/");
1483 return LT_matrix;
1484}
1485
1486List<Eigen::MatrixXd> msrProblem::temp_XSfluxsource(label NTmodes,
1487 label NFluxmodes, label NCmodes)
1488{
1489 label TXSsize = NTmodes + liftfieldT.size();
1490 List<Eigen::MatrixXd> TXS_matrix;
1491 TXS_matrix.setSize(TXSsize);
1492
1493 for (label j = 0; j < TXSsize; j++)
1494 {
1495 TXS_matrix[j].resize(NCmodes, NFluxmodes);
1496 TXS_matrix[j].setZero();
1497 }
1498
1499 PtrList<volScalarField> TogetherT(0);
1500
1501 if (liftfieldT.size() != 0)
1502 {
1503 for (label k = 0; k < liftfieldT.size(); k++)
1504 {
1505 TogetherT.append(liftfieldT[k].clone());
1506 }
1507 }
1508
1509 if (NTmodes != 0)
1510 {
1511 for (label k = 0; k < NTmodes; k++)
1512 {
1513 TogetherT.append(Tmodes[k].clone());
1514 }
1515 }
1516
1517 // Project everything
1518 for (label i = 0; i < TXSsize; i++)
1519 {
1520 for (label j = 0; j < NCmodes; j++)
1521 {
1522 for (label k = 0; k < NFluxmodes; k++)
1523 {
1524 TXS_matrix[i](j, k) = fvc::domainIntegrate(TogetherT[i] * TXSmodes[j] *
1525 Fluxmodes[k]).value();
1526 }
1527 }
1528 }
1529
1530 ITHACAstream::exportMatrix(TXS_matrix, "TXS", "matlab",
1531 "./ITHACAoutput/Matrices/thermal/");
1532 return TXS_matrix;
1533}
1534
1535List<Eigen::MatrixXd> msrProblem::temp_heatsource(label NTmodes,
1536 label NDecmodes, label NCmodes, label decgroup)
1537{
1538 label g = decgroup;
1539 PtrList<volScalarField> Decmodes = choose_group("dec", g);
1540 label THSsize = NTmodes + liftfieldT.size();
1541 List<Eigen::MatrixXd> THS_matrix;
1542 THS_matrix.setSize(THSsize);
1543
1544 for (label j = 0; j < THSsize; j++)
1545 {
1546 THS_matrix[j].resize(NCmodes, NDecmodes);
1547 THS_matrix[j].setZero();
1548 }
1549
1550 PtrList<volScalarField> TogetherT(0);
1551
1552 if (liftfieldT.size() != 0)
1553 {
1554 for (label k = 0; k < liftfieldT.size(); k++)
1555 {
1556 TogetherT.append(liftfieldT[k].clone());
1557 }
1558 }
1559
1560 if (NTmodes != 0)
1561 {
1562 for (label k = 0; k < NTmodes; k++)
1563 {
1564 TogetherT.append(Tmodes[k].clone());
1565 }
1566 }
1567
1568 // Project everything
1569 for (label i = 0; i < THSsize; i++)
1570 {
1571 for (label j = 0; j < NCmodes; j++)
1572 {
1573 for (label k = 0; k < NDecmodes; k++)
1574 {
1575 THS_matrix[i](j, k) = fvc::domainIntegrate(TogetherT[i] * vmodes[j] *
1576 Decmodes[k]).value();
1577 }
1578 }
1579 }
1580
1581 savegroupMatrix("THS", g, "./ITHACAoutput/Matrices/thermal/", THS_matrix);
1582 return THS_matrix;
1583}
1584
1585PtrList<volScalarField> msrProblem::choose_group(string field, label ith)
1586{
1587 if (field == "prec")
1588 {
1589 switch (ith)
1590 {
1591 case 1:
1592 return Prec1modes;
1593 break;
1594
1595 case 2:
1596 return Prec2modes;
1597 break;
1598
1599 case 3:
1600 return Prec3modes;
1601 break;
1602
1603 case 4:
1604 return Prec4modes;
1605 break;
1606
1607 case 5:
1608 return Prec5modes;
1609 break;
1610
1611 case 6:
1612 return Prec6modes;
1613 break;
1614
1615 case 7:
1616 return Prec7modes;
1617 break;
1618
1619 case 8:
1620 return Prec8modes;
1621 break;
1622 }
1623 }
1624
1625 if (field == "dec")
1626 {
1627 switch (ith)
1628 {
1629 case 1:
1630 return Dec1modes;
1631 break;
1632
1633 case 2:
1634 return Dec2modes;
1635 break;
1636
1637 case 3:
1638 return Dec3modes;
1639 break;
1640 }
1641 }
1642}
1643
1644
1645template<typename M>
1646void msrProblem::savegroupMatrix(string nome, label n, word folder, M matrice)
1647{
1648 nome.append(std::to_string(n));
1649 word name = nome;
1650 ITHACAstream::exportMatrix(matrice, name, "matlab", folder);
1651}
1652
1653void msrProblem::homogenizeU()
1654{
1655 computeLift(Ufield, liftfield, Uomfield);
1656 homboolU = true;
1657}
1658
1659void msrProblem::homogenizeT()
1660{
1661 computeLiftT(Tfield, liftfieldT, Tomfield);
1662 homboolT = true;
1663}
1664
1665void msrProblem::readMSRfields()
1666{
1667 volVectorField& U = _U();
1668 volScalarField& p = _p();
1669 volScalarField& flux = _flux();
1670 volScalarField& prec1 = _prec1();
1671 volScalarField& prec2 = _prec2();
1672 volScalarField& prec3 = _prec3();
1673 volScalarField& prec4 = _prec4();
1674 volScalarField& prec5 = _prec5();
1675 volScalarField& prec6 = _prec6();
1676 volScalarField& prec7 = _prec7();
1677 volScalarField& prec8 = _prec8();
1678 volScalarField& T = _T();
1679 volScalarField& dec1 = _dec1();
1680 volScalarField& dec2 = _dec2();
1681 volScalarField& dec3 = _dec3();
1682 volScalarField& v = _v();
1683 volScalarField& D = _D();
1684 volScalarField& NSF = _NSF();
1685 volScalarField& A = _A();
1686 volScalarField& SP = _SP();
1687 volScalarField& TXS = _TXS();
1688 volScalarField powerDens = (flux * (1 - _decbetaTot()) * _SP() + _decLam1() *
1689 dec1 + _decLam2() * dec2 + _decLam3() * dec3).ref();
1690 powerDens.rename("powerDens");
1691 ITHACAstream::read_fields(Ufield, U, "./ITHACAoutput/Offline/");
1692 ITHACAstream::read_fields(Pfield, p, "./ITHACAoutput/Offline/");
1693 ITHACAstream::read_fields(Fluxfield, flux, "./ITHACAoutput/Offline/");
1694 ITHACAstream::read_fields(Tfield, T, "./ITHACAoutput/Offline/");
1695 ITHACAstream::read_fields(Prec1field, prec1, "./ITHACAoutput/Offline/");
1696 ITHACAstream::read_fields(Prec2field, prec2, "./ITHACAoutput/Offline/");
1697 ITHACAstream::read_fields(Prec3field, prec3, "./ITHACAoutput/Offline/");
1698 ITHACAstream::read_fields(Prec4field, prec4, "./ITHACAoutput/Offline/");
1699 ITHACAstream::read_fields(Prec5field, prec5, "./ITHACAoutput/Offline/");
1700 ITHACAstream::read_fields(Prec6field, prec6, "./ITHACAoutput/Offline/");
1701 ITHACAstream::read_fields(Prec7field, prec7, "./ITHACAoutput/Offline/");
1702 ITHACAstream::read_fields(Prec8field, prec8, "./ITHACAoutput/Offline/");
1703 ITHACAstream::read_fields(Dec1field, dec1, "./ITHACAoutput/Offline/");
1704 ITHACAstream::read_fields(Dec2field, dec2, "./ITHACAoutput/Offline/");
1705 ITHACAstream::read_fields(Dec3field, dec3, "./ITHACAoutput/Offline/");
1706 ITHACAstream::read_fields(PowerDensfield, powerDens, "./ITHACAoutput/Offline/");
1707 ITHACAstream::read_fields(vFields, v, "./ITHACAoutput/Offline/");
1708 ITHACAstream::read_fields(DFields, D, "./ITHACAoutput/Offline/");
1709 ITHACAstream::read_fields(NSFFields, NSF, "./ITHACAoutput/Offline/");
1710 ITHACAstream::read_fields(AFields, A, "./ITHACAoutput/Offline/");
1711 ITHACAstream::read_fields(SPFields, SP, "./ITHACAoutput/Offline/");
1712 ITHACAstream::read_fields(TXSFields, TXS, "./ITHACAoutput/Offline/");
1713 mu_samples =
1714 ITHACAstream::readMatrix("./ITHACAoutput/Offline/mu_samples_mat.txt");
1715}
1716
1717void msrProblem::readMSRfields(std::string& dir)
1718{
1719 volVectorField& U = _U();
1720 volScalarField& p = _p();
1721 volScalarField& flux = _flux();
1722 volScalarField& prec1 = _prec1();
1723 volScalarField& prec2 = _prec2();
1724 volScalarField& prec3 = _prec3();
1725 volScalarField& prec4 = _prec4();
1726 volScalarField& prec5 = _prec5();
1727 volScalarField& prec6 = _prec6();
1728 volScalarField& prec7 = _prec7();
1729 volScalarField& prec8 = _prec8();
1730 volScalarField& T = _T();
1731 volScalarField& dec1 = _dec1();
1732 volScalarField& dec2 = _dec2();
1733 volScalarField& dec3 = _dec3();
1734 volScalarField& v = _v();
1735 volScalarField& D = _D();
1736 volScalarField& NSF = _NSF();
1737 volScalarField& A = _A();
1738 volScalarField& SP = _SP();
1739 volScalarField& TXS = _TXS();
1740 volScalarField powerDens = (flux * (1 - _decbetaTot()) * _SP() + _decLam1() *
1741 dec1 + _decLam2() * dec2 + _decLam3() * dec3).ref();
1742 powerDens.rename("powerDens");
1743 std::string folder = dir;
1744
1745 if (ITHACAutilities::check_folder(folder) == true)
1746 {
1747 for (label i = 0; i < mu.cols(); i++)
1748 {
1749 folder.append(std::to_string(i));
1750 folder.append("/");
1751 ITHACAstream::read_fields(Ufield, U, folder);
1752 ITHACAstream::read_fields(Pfield, p, folder);
1753 ITHACAstream::read_fields(Fluxfield, flux, folder);
1754 ITHACAstream::read_fields(Tfield, T, folder);
1755 ITHACAstream::read_fields(Prec1field, prec1, folder);
1756 ITHACAstream::read_fields(Prec2field, prec2, folder);
1757 ITHACAstream::read_fields(Prec3field, prec3, folder);
1758 ITHACAstream::read_fields(Prec4field, prec4, folder);
1759 ITHACAstream::read_fields(Prec5field, prec5, folder);
1760 ITHACAstream::read_fields(Prec6field, prec6, folder);
1761 ITHACAstream::read_fields(Prec7field, prec7, folder);
1762 ITHACAstream::read_fields(Prec8field, prec8, folder);
1763 ITHACAstream::read_fields(Dec1field, dec1, folder);
1764 ITHACAstream::read_fields(Dec2field, dec2, folder);
1765 ITHACAstream::read_fields(Dec3field, dec3, folder);
1766 ITHACAstream::read_fields(PowerDensfield, powerDens, folder);
1767 ITHACAstream::read_fields(vFields, v, folder);
1768 ITHACAstream::read_fields(DFields, D, folder);
1769 ITHACAstream::read_fields(NSFFields, NSF, folder);
1770 ITHACAstream::read_fields(AFields, A, folder);
1771 ITHACAstream::read_fields(SPFields, SP, folder);
1772 ITHACAstream::read_fields(TXSFields, TXS, folder);
1773 folder = dir;
1774 }
1775 }
1776 else
1777 {
1778 Info << "Error" << endl;
1779 }
1780}
1781
1782
1783void msrProblem::change_viscosity(double mu)
1784{
1785 const volScalarField& nu = _laminarTransport().nu();
1786 volScalarField& ciao = const_cast<volScalarField&>(nu);
1787 this->assignIF(ciao, mu);
1788
1789 for (label i = 0; i < ciao.boundaryFieldRef().size(); i++)
1790 {
1791 this->assignBC(ciao, i, mu);
1792 }
1793}
1794
1795void msrProblem::msrcoeff(label& NC)
1796{
1797 NCmodes = NC;
1798 Eigen::MatrixXd Ncoeff_v = ITHACAutilities::getCoeffs(vFields, vmodes);
1799 ITHACAstream::exportMatrix(Ncoeff_v, "Ncoeff_v", "matlab",
1800 "./ITHACAoutput/Matrices/");
1801 label Ncol = Ncoeff_v.cols();
1802 SAMPLES_v.resize(NCmodes);
1803 rbfsplines_v.resize(NCmodes);
1804
1805 for (label i = 0; i < NCmodes; i++)
1806 {
1807 Info << "Constructing v RadialBasisFunction for mode " << i + 1 <<
1808 endl;
1809 SAMPLES_v[i] = new SPLINTER::DataTable(1, 1);
1810
1811 for (label j = 0; j < Ncol; j++)
1812 {
1813 SAMPLES_v[i]->addSample(mu_samples.row(j), Ncoeff_v(i, j));
1814 }
1815
1816 rbfsplines_v[i] = new SPLINTER::RBFSpline(* SAMPLES_v[i],
1817 SPLINTER::RadialBasisFunctionType::GAUSSIAN);
1818 }
1819
1820 Eigen::MatrixXd Ncoeff_D = ITHACAutilities::getCoeffs(DFields, Dmodes);
1821 ITHACAstream::exportMatrix(Ncoeff_D, "Ncoeff_D", "matlab",
1822 "./ITHACAoutput/Matrices/");
1823 SAMPLES_D.resize(NCmodes);
1824 rbfsplines_D.resize(NCmodes);
1825
1826 for (label i = 0; i < NCmodes; i++)
1827 {
1828 Info << "Constructing D RadialBasisFunction for mode " << i + 1 <<
1829 endl;
1830 SAMPLES_D[i] = new SPLINTER::DataTable(1, 1);
1831
1832 for (label j = 0; j < Ncol; j++)
1833 {
1834 SAMPLES_D[i]->addSample(mu_samples.row(j), Ncoeff_D(i, j));
1835 }
1836
1837 rbfsplines_D[i] = new SPLINTER::RBFSpline(* SAMPLES_D[i],
1838 SPLINTER::RadialBasisFunctionType::GAUSSIAN);
1839 }
1840
1841 Eigen::MatrixXd Ncoeff_NSF = ITHACAutilities::getCoeffs(NSFFields,
1842 NSFmodes);
1843 ITHACAstream::exportMatrix(Ncoeff_NSF, "Ncoeff_NSF", "matlab",
1844 "./ITHACAoutput/Matrices/");
1845 SAMPLES_NSF.resize(NCmodes);
1846 rbfsplines_NSF.resize(NCmodes);
1847
1848 for (label i = 0; i < NCmodes; i++)
1849 {
1850 Info << "Constructing NSF RadialBasisFunction for mode " << i + 1 <<
1851 endl;
1852 SAMPLES_NSF[i] = new SPLINTER::DataTable(1, 1);
1853
1854 for (label j = 0; j < Ncol; j++)
1855 {
1856 SAMPLES_NSF[i]->addSample(mu_samples.row(j), Ncoeff_NSF(i, j));
1857 }
1858
1859 rbfsplines_NSF[i] = new SPLINTER::RBFSpline(* SAMPLES_NSF[i],
1860 SPLINTER::RadialBasisFunctionType::GAUSSIAN);
1861 }
1862
1863 Eigen::MatrixXd Ncoeff_A = ITHACAutilities::getCoeffs(AFields, Amodes);
1864 ITHACAstream::exportMatrix(Ncoeff_A, "Ncoeff_A", "matlab",
1865 "./ITHACAoutput/Matrices/");
1866 SAMPLES_A.resize(NCmodes);
1867 rbfsplines_A.resize(NCmodes);
1868
1869 for (label i = 0; i < NCmodes; i++)
1870 {
1871 Info << "Constructing A RadialBasisFunction for mode " << i + 1 <<
1872 endl;
1873 SAMPLES_A[i] = new SPLINTER::DataTable(1, 1);
1874
1875 for (label j = 0; j < Ncol; j++)
1876 {
1877 SAMPLES_A[i]->addSample(mu_samples.row(j), Ncoeff_A(i, j));
1878 }
1879
1880 rbfsplines_A[i] = new SPLINTER::RBFSpline(* SAMPLES_A[i],
1881 SPLINTER::RadialBasisFunctionType::GAUSSIAN);
1882 }
1883
1884 Eigen::MatrixXd Ncoeff_SP = ITHACAutilities::getCoeffs(SPFields,
1885 SPmodes);
1886 ITHACAstream::exportMatrix(Ncoeff_SP, "Ncoeff_SP", "matlab",
1887 "./ITHACAoutput/Matrices/");
1888 SAMPLES_SP.resize(NCmodes);
1889 rbfsplines_SP.resize(NCmodes);
1890
1891 for (label i = 0; i < NCmodes; i++)
1892 {
1893 Info << "Constructing SP RadialBasisFunction for mode " << i + 1 <<
1894 endl;
1895 SAMPLES_SP[i] = new SPLINTER::DataTable(1, 1);
1896
1897 for (label j = 0; j < Ncol; j++)
1898 {
1899 SAMPLES_SP[i]->addSample(mu_samples.row(j), Ncoeff_SP(i, j));
1900 }
1901
1902 rbfsplines_SP[i] = new SPLINTER::RBFSpline(* SAMPLES_SP[i],
1903 SPLINTER::RadialBasisFunctionType::GAUSSIAN);
1904 }
1905
1906 Eigen::MatrixXd Ncoeff_TXS = ITHACAutilities::getCoeffs(TXSFields,
1907 TXSmodes);
1908 ITHACAstream::exportMatrix(Ncoeff_TXS, "Ncoeff_TXS", "matlab",
1909 "./ITHACAoutput/Matrices/");
1910 SAMPLES_TXS.resize(NCmodes);
1911 rbfsplines_TXS.resize(NCmodes);
1912
1913 for (label i = 0; i < NCmodes; i++)
1914 {
1915 Info << "Constructing TXS RadialBasisFunction for mode " << i + 1 <<
1916 endl;
1917 SAMPLES_TXS[i] = new SPLINTER::DataTable(1, 1);
1918
1919 for (label j = 0; j < Ncol; j++)
1920 {
1921 SAMPLES_TXS[i]->addSample(mu_samples.row(j), Ncoeff_TXS(i, j));
1922 }
1923
1924 rbfsplines_TXS[i] = new SPLINTER::RBFSpline(* SAMPLES_TXS[i],
1925 SPLINTER::RadialBasisFunctionType::GAUSSIAN);
1926 }
1927}
1928
1929
1930void msrProblem::liftSolveT()
1931{
1932 for (label k = 0; k < inletIndexT.rows(); k++)
1933 {
1934 Time& runTime = _runTime();
1935 fvMesh& mesh = _mesh();
1936 volScalarField& T = _T();
1937 volVectorField& U = _U();
1938 surfaceScalarField& phi = _phi();
1939 phi = linearInterpolate(U) & mesh.Sf();
1940 //pisoControl potentialFlow(mesh,"potentialFLow");
1941 simpleControl simple(mesh);
1942 IOMRFZoneList& MRF = _MRF();
1943 singlePhaseTransportModel& laminarTransport = _laminarTransport();
1944 turbulence = autoPtr<incompressible::turbulenceModel>
1945 (
1946 incompressible::turbulenceModel::New(U, phi, laminarTransport)
1947 );
1948 dimensionedScalar& nu = _nu();
1949 dimensionedScalar& Pr = _Pr();
1950 dimensionedScalar& Prt = _Prt();
1951 volScalarField& alphat = _alphat();
1952 volScalarField& v = _v();
1953 dimensionedScalar& cp = _CpRef();
1954 dimensionedScalar& rho = _rhoRef();
1955 dimensionedScalar& sp = _SP1_0();
1956 dimensionedScalar& dbtot = _decbetaTot();
1957 label BCind = inletIndexT(k, 0);
1958 volScalarField Tlift("Tlift" + name(k), T);
1959 instantList Times = runTime.times();
1960 runTime.setTime(Times[1], 1);
1961 Info << "Solving a lifting Problem" << endl;
1962 scalar t1 = 1;
1963 scalar t0 = 0;
1964 alphat = turbulence->nut() / Prt;
1965 alphat.correctBoundaryConditions();
1966 volScalarField source
1967 (
1968 IOobject
1969 (
1970 "source",
1971 runTime.timeName(),
1972 mesh,
1973 IOobject::NO_READ,
1974 IOobject::AUTO_WRITE
1975 ),
1976 mesh,
1977 dimensionedScalar("source", dimensionSet(0, -2, -1, 0, 0, 0, 0), 1)
1978 );
1979
1980 for (label j = 0; j < T.boundaryField().size(); j++)
1981 {
1982 if (j == BCind)
1983 {
1984 assignBC(Tlift, j, t1);
1985 assignIF(Tlift, t0);
1986 }
1987 else if (T.boundaryField()[BCind].type() == "fixedValue")
1988 {
1989 assignBC(Tlift, j, t0);
1990 assignIF(Tlift, t0);
1991 }
1992 else
1993 {
1994 }
1995 }
1996
1997 while (simple.correctNonOrthogonal())
1998 {
1999 fvScalarMatrix TEqn
2000 (
2001 fvm::div(phi, Tlift) == fvm::laplacian(turbulence->nu() / Pr + alphat, Tlift)
2002 + sp * (1 - dbtot) / (cp * rho) * source
2003 );
2004 TEqn.solve();
2005 Info << "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
2006 << " ClockTime = " << runTime.elapsedClockTime() << " s"
2007 << nl << endl;
2008 }
2009
2010 Tlift.write();
2011 liftfieldT.append(Tlift.clone());
2012 }
2013}
2014
2015
2016void msrProblem::restart()
2017{
2018 volScalarField& p = _p();
2019 volScalarField& p0 = _p0();
2020 volVectorField& U = _U();
2021 volVectorField& U0 = _U0();
2022 surfaceScalarField& phi = _phi();
2023 surfaceScalarField& phi0 = _phi0();
2024 volScalarField& flux = _flux();
2025 volScalarField& flux0 = _flux0();
2026 volScalarField& prec1 = _prec1();
2027 volScalarField& prec10 = _prec10();
2028 volScalarField& prec2 = _prec2();
2029 volScalarField& prec20 = _prec20();
2030 volScalarField& prec3 = _prec3();
2031 volScalarField& prec30 = _prec30();
2032 volScalarField& prec4 = _prec4();
2033 volScalarField& prec40 = _prec40();
2034 volScalarField& prec5 = _prec5();
2035 volScalarField& prec50 = _prec50();
2036 volScalarField& prec6 = _prec6();
2037 volScalarField& prec60 = _prec60();
2038 volScalarField& prec7 = _prec7();
2039 volScalarField& prec70 = _prec70();
2040 volScalarField& prec8 = _prec8();
2041 volScalarField& prec80 = _prec80();
2042 volScalarField& T = _T();
2043 volScalarField& T0 = _T0();
2044 volScalarField& dec1 = _dec1();
2045 volScalarField& dec10 = _dec10();
2046 volScalarField& dec2 = _dec2();
2047 volScalarField& dec20 = _dec20();
2048 volScalarField& dec3 = _dec3();
2049 volScalarField& dec30 = _dec30();
2050 dimensionedScalar& Keff = _Keff();
2051 dimensionedScalar& K0 = _K0();
2052 volScalarField& v = _v();
2053 volScalarField& v0 = _v0();
2054 volScalarField& NSF = _NSF();
2055 volScalarField& NSF0 = _NSF0();
2056 volScalarField& A = _A();
2057 volScalarField& A0 = _A0();
2058 volScalarField& D = _D();
2059 volScalarField& D0 = _D0();
2060 volScalarField& SP = _SP();
2061 volScalarField& SP0 = _SP0();
2062 volScalarField& TXS = _TXS();
2063 volScalarField& TXS0 = _TXS0();
2064 fvMesh& mesh = _mesh();
2065 p = p0;
2066 U = U0;
2067 phi = phi0;
2068 turbulence.reset(
2069 (incompressible::turbulenceModel::New(U, phi, _laminarTransport())).ptr()
2070 );
2071 flux = flux0;
2072 prec1 = prec10;
2073 prec2 = prec20;
2074 prec3 = prec30;
2075 prec4 = prec40;
2076 prec5 = prec50;
2077 prec6 = prec60;
2078 prec7 = prec70;
2079 prec8 = prec80;
2080
2081 if (precInBool == true)
2082 {
2083 prec1.boundaryFieldRef().set(precinIndex,
2084 fvPatchField<scalar>::New(prec10.boundaryField()[precinIndex].type(),
2085 mesh.boundary()[precinIndex], prec1));
2086 prec2.boundaryFieldRef().set(precinIndex,
2087 fvPatchField<scalar>::New(prec20.boundaryField()[precinIndex].type(),
2088 mesh.boundary()[precinIndex], prec2));
2089 prec3.boundaryFieldRef().set(precinIndex,
2090 fvPatchField<scalar>::New(prec30.boundaryField()[precinIndex].type(),
2091 mesh.boundary()[precinIndex], prec3));
2092 prec4.boundaryFieldRef().set(precinIndex,
2093 fvPatchField<scalar>::New(prec40.boundaryField()[precinIndex].type(),
2094 mesh.boundary()[precinIndex], prec4));
2095 prec5.boundaryFieldRef().set(precinIndex,
2096 fvPatchField<scalar>::New(prec50.boundaryField()[precinIndex].type(),
2097 mesh.boundary()[precinIndex], prec5));
2098 prec6.boundaryFieldRef().set(precinIndex,
2099 fvPatchField<scalar>::New(prec60.boundaryField()[precinIndex].type(),
2100 mesh.boundary()[precinIndex], prec6));
2101 prec7.boundaryFieldRef().set(precinIndex,
2102 fvPatchField<scalar>::New(prec70.boundaryField()[precinIndex].type(),
2103 mesh.boundary()[precinIndex], prec7));
2104 prec8.boundaryFieldRef().set(precinIndex,
2105 fvPatchField<scalar>::New(prec80.boundaryField()[precinIndex].type(),
2106 mesh.boundary()[precinIndex], prec8));
2107 }
2108
2109 T = T0;
2110 dec1 = dec10;
2111 dec2 = dec20;
2112 dec3 = dec30;
2113 Keff = K0;
2114 v = v0;
2115 NSF = NSF0;
2116 A = A0;
2117 D = D0;
2118 SP = SP0;
2119 TXS = TXS0;
2120}
2121
2122
2123
2124
2125
2126
2127
ITHACAparameters::getInstance
static ITHACAparameters * getInstance()
Gets an instance of ITHACAparameters, to be used if the instance is already existing.
Definition ITHACAparameters.C:56
msrProblem::stream_term
List< Eigen::MatrixXd > stream_term(label NUmodes, label NPrecmodes, label family)
precursor eq. methods:
Definition msrProblem.C:1078
msrProblem::MP7_matrix
Eigen::MatrixXd MP7_matrix
precursor mass term-7
Definition msrProblem.H:418
msrProblem::MD1_matrix
Eigen::MatrixXd MD1_matrix
decay heat mass term-1
Definition msrProblem.H:464
msrProblem::homogenizeT
void homogenizeT()
Method to compute the homogenized temperature field, it also sets homboolT=true.
Definition msrProblem.C:1659
msrProblem::ST5_matrix
List< Eigen::MatrixXd > ST5_matrix
precursor stream term-5
Definition msrProblem.H:398
msrProblem::Prec6field
PtrList< volScalarField > Prec6field
List of pointers used to form the prec6 snapshots matrix.
Definition msrProblem.H:219
msrProblem::THS2_matrix
List< Eigen::MatrixXd > THS2_matrix
temperature decay heat source term-2
Definition msrProblem.H:493
msrProblem::LP3_matrix
Eigen::MatrixXd LP3_matrix
precursor laplacian term-3
Definition msrProblem.H:426
msrProblem::SD1_matrix
List< Eigen::MatrixXd > SD1_matrix
decay heat stream term-1
Definition msrProblem.H:458
msrProblem::BC1_matrix
Eigen::MatrixXd BC1_matrix
PPE BC1.
Definition msrProblem.H:350
msrProblem::NSFmodes
PtrList< volScalarField > NSFmodes
List of pointers used to form the NSF snapshosts matrix.
Definition msrProblem.H:312
msrProblem::Prec5modes
PtrList< volScalarField > Prec5modes
List of pointers used to form the prec1 modes.
Definition msrProblem.H:282
msrProblem::PF_matrix
List< Eigen::MatrixXd > PF_matrix
production flux
Definition msrProblem.H:366
msrProblem::choose_group
PtrList< volScalarField > choose_group(string field, label ith)
method to choose one field among precs & decs field can be "prec" or "dec" only if field==prec then i...
Definition msrProblem.C:1585
msrProblem::savegroupMatrix
void savegroupMatrix(string nome, label n, word folder, M matrice)
method to save matrices for precs and decs M can be an Eigen::MatrixXd or List<Eigen::MatrixXd> nome ...
Definition msrProblem.C:1646
msrProblem::Prec4modes
PtrList< volScalarField > Prec4modes
List of pointers used to form the prec1 modes.
Definition msrProblem.H:279
msrProblem::FS3_matrix
List< Eigen::MatrixXd > FS3_matrix
precursor flux source term-3
Definition msrProblem.H:442
msrProblem::BC2_matrix
List< Eigen::MatrixXd > BC2_matrix
PPE BC2.
Definition msrProblem.H:353
msrProblem::ST7_matrix
List< Eigen::MatrixXd > ST7_matrix
precursor stream term-7
Definition msrProblem.H:402
msrProblem::Prec8field
PtrList< volScalarField > Prec8field
List of pointers used to form the prec8 snapshots matrix.
Definition msrProblem.H:225
msrProblem::FS1_matrix
List< Eigen::MatrixXd > FS1_matrix
precursor flux source term-1
Definition msrProblem.H:438
msrProblem::Prec1modes
PtrList< volScalarField > Prec1modes
List of pointers used to form the prec1 modes.
Definition msrProblem.H:270
msrProblem::TXS_matrix
List< Eigen::MatrixXd > TXS_matrix
temperature flux source term TXS
Definition msrProblem.H:489
msrProblem::LF_matrix
List< Eigen::MatrixXd > LF_matrix
laplacian_flux
Definition msrProblem.H:362
msrProblem::Pmodes
PtrList< volScalarField > Pmodes
List of pointers used to form the pressure modes.
Definition msrProblem.H:261
msrProblem::NUmodes
label NUmodes
Number of modes adopted during Galerkin projection.
Definition msrProblem.H:500
msrProblem::MP1_matrix
Eigen::MatrixXd MP1_matrix
precursor mass term-1
Definition msrProblem.H:406
msrProblem::ST8_matrix
List< Eigen::MatrixXd > ST8_matrix
precursor stream term-8
Definition msrProblem.H:404
msrProblem::Uomfield
PtrList< volVectorField > Uomfield
List of pointers used to form the homogeneous velocity snapshots.
Definition msrProblem.H:517
msrProblem::ST4_matrix
List< Eigen::MatrixXd > ST4_matrix
precursor stream term-4
Definition msrProblem.H:396
msrProblem::Prec7modes
PtrList< volScalarField > Prec7modes
List of pointers used to form the prec1 modes.
Definition msrProblem.H:288
msrProblem::vFields
PtrList< volScalarField > vFields
List of pointers used to form the v snapshosts matrix.
Definition msrProblem.H:243
msrProblem::PS3_matrix
Eigen::MatrixXd PS3_matrix
prec_source 3
Definition msrProblem.H:377
msrProblem::Tmodes
PtrList< volScalarField > Tmodes
List of pointers used to form the temperature modes.
Definition msrProblem.H:294
msrProblem::precinIndex
label precinIndex
indexes of inlet and outlet to adopt for precursors boundary conditions
Definition msrProblem.H:184
msrProblem::K_matrix
Eigen::MatrixXd K_matrix
Gradient of pressure matrix.
Definition msrProblem.H:335
msrProblem::G_matrix
List< Eigen::MatrixXd > G_matrix
Divergence of momentum PPE.
Definition msrProblem.H:347
msrProblem::AF_matrix
List< Eigen::MatrixXd > AF_matrix
absorption flux
Definition msrProblem.H:368
msrProblem::MP2_matrix
Eigen::MatrixXd MP2_matrix
precursor mass term-2
Definition msrProblem.H:408
msrProblem::FS2_matrix
List< Eigen::MatrixXd > FS2_matrix
precursor flux source term-2
Definition msrProblem.H:440
msrProblem::LP8_matrix
Eigen::MatrixXd LP8_matrix
precursor laplacian term-8
Definition msrProblem.H:436
msrProblem::PS6_matrix
Eigen::MatrixXd PS6_matrix
prec_source 6
Definition msrProblem.H:383
msrProblem::Prec8modes
PtrList< volScalarField > Prec8modes
List of pointers used to form the prec1 modes.
Definition msrProblem.H:291
msrProblem::FS4_matrix
List< Eigen::MatrixXd > FS4_matrix
precursor flux source term-4
Definition msrProblem.H:444
msrProblem::Fluxfield
PtrList< volScalarField > Fluxfield
List of pointers used to form the flux snapshots matrix.
Definition msrProblem.H:201
msrProblem::BC3_matrix
Eigen::MatrixXd BC3_matrix
PPE BC3.
Definition msrProblem.H:356
msrProblem::LP4_matrix
Eigen::MatrixXd LP4_matrix
precursor laplacian term-4
Definition msrProblem.H:428
msrProblem::LP7_matrix
Eigen::MatrixXd LP7_matrix
precursor laplacian term-7
Definition msrProblem.H:434
msrProblem::TM_matrix
Eigen::MatrixXd TM_matrix
temperature mass term
Definition msrProblem.H:483
msrProblem::SD3_matrix
List< Eigen::MatrixXd > SD3_matrix
decay heat stream term-3
Definition msrProblem.H:462
msrProblem::Prec2modes
PtrList< volScalarField > Prec2modes
List of pointers used to form the prec1 modes.
Definition msrProblem.H:273
msrProblem::LP6_matrix
Eigen::MatrixXd LP6_matrix
precursor laplacian term-6
Definition msrProblem.H:432
msrProblem::TS_matrix
List< Eigen::MatrixXd > TS_matrix
temperature stream term
Definition msrProblem.H:485
msrProblem::MF_matrix
Eigen::MatrixXd MF_matrix
mass flux
Definition msrProblem.H:364
msrProblem::Prec4field
PtrList< volScalarField > Prec4field
List of pointers used to form the prec4 snapshots matrix.
Definition msrProblem.H:213
msrProblem::MP3_matrix
Eigen::MatrixXd MP3_matrix
precursor mass term-3
Definition msrProblem.H:410
msrProblem::DFields
PtrList< volScalarField > DFields
List of pointers used to form the D snapshosts matrix.
Definition msrProblem.H:246
msrProblem::D_matrix
Eigen::MatrixXd D_matrix
Laplacian term PPE.
Definition msrProblem.H:344
msrProblem::DFS2_matrix
List< Eigen::MatrixXd > DFS2_matrix
decay heat flux source term-2
Definition msrProblem.H:478
msrProblem::change_viscosity
void change_viscosity(double mu)
method to change the viscosity in UEqn
Definition msrProblem.C:1783
msrProblem::laplacian_flux
List< Eigen::MatrixXd > laplacian_flux(label NFluxmodes, label NCmodes)
diffusion eq. methods:
Definition msrProblem.C:938
msrProblem::AFields
PtrList< volScalarField > AFields
List of pointers used to form the A snapshosts matrix.
Definition msrProblem.H:252
msrProblem::PS7_matrix
Eigen::MatrixXd PS7_matrix
prec_source 7
Definition msrProblem.H:385
msrProblem::FS7_matrix
List< Eigen::MatrixXd > FS7_matrix
precursor flux source term-7
Definition msrProblem.H:450
msrProblem::ST6_matrix
List< Eigen::MatrixXd > ST6_matrix
precursor stream term-6
Definition msrProblem.H:400
msrProblem::readMSRfields
void readMSRfields()
Method to read all the fieds of the MSR problem in the offline folder, it also reads mu_samples matri...
Definition msrProblem.C:1665
msrProblem::LP1_matrix
Eigen::MatrixXd LP1_matrix
precursor laplacian term-1
Definition msrProblem.H:422
msrProblem::Dec1modes
PtrList< volScalarField > Dec1modes
List of pointers used to form the dec1 modes.
Definition msrProblem.H:297
msrProblem::THS1_matrix
List< Eigen::MatrixXd > THS1_matrix
temperature decay heat source term-1
Definition msrProblem.H:491
msrProblem::Dec3field
PtrList< volScalarField > Dec3field
List of pointers used to form the dec3 snapshots matrix.
Definition msrProblem.H:237
msrProblem::ST1_matrix
List< Eigen::MatrixXd > ST1_matrix
precursor stream term-1
Definition msrProblem.H:390
msrProblem::liftSolve
void liftSolve()
Perform a lift solve for the velocity field.
Definition msrProblem.C:291
msrProblem::LT_matrix
Eigen::MatrixXd LT_matrix
temperature laplacian term
Definition msrProblem.H:487
msrProblem::Prec6modes
PtrList< volScalarField > Prec6modes
List of pointers used to form the prec1 modes.
Definition msrProblem.H:285
msrProblem::liftSolveT
void liftSolveT()
Perform a lift solve for the temperature.
Definition msrProblem.C:1930
msrProblem::FS6_matrix
List< Eigen::MatrixXd > FS6_matrix
precursor flux source term-6
Definition msrProblem.H:448
msrProblem::mass_temp
Eigen::MatrixXd mass_temp(label NTmodes)
temperature eq. methods
Definition msrProblem.C:1340
msrProblem::vmodes
PtrList< volScalarField > vmodes
List of pointers used to form the v modes.
Definition msrProblem.H:306
msrProblem::P_matrix
Eigen::MatrixXd P_matrix
Div of velocity.
Definition msrProblem.H:341
msrProblem::_fvOptions
autoPtr< fv::options > _fvOptions
fvOptions
Definition msrProblem.H:168
msrProblem::tolerance
scalar tolerance
Tolerance for the residual of the stationary problems, there is the same tolerance for velocity and p...
Definition msrProblem.H:175
msrProblem::Dec1field
PtrList< volScalarField > Dec1field
List of pointers used to form the dec1 snapshots matrix.
Definition msrProblem.H:231
msrProblem::maxIter
scalar maxIter
Number of maximum iterations to be done for the computation of the truth solution.
Definition msrProblem.H:177
msrProblem::TXSmodes
PtrList< volScalarField > TXSmodes
List of pointers used to form the SP snapshosts matrix.
Definition msrProblem.H:321
msrProblem::divergence_term
Eigen::MatrixXd divergence_term(label NUmodes, label NPmodes)
continuity eq. methods:
Definition msrProblem.C:672
msrProblem::LD1_matrix
Eigen::MatrixXd LD1_matrix
decay heat laplacian term-1
Definition msrProblem.H:470
msrProblem::SD2_matrix
List< Eigen::MatrixXd > SD2_matrix
decay heat stream term-2
Definition msrProblem.H:460
msrProblem::_simple
autoPtr< simpleControl > _simple
simpleControl
Definition msrProblem.H:173
msrProblem::MP5_matrix
Eigen::MatrixXd MP5_matrix
precursor mass term-5
Definition msrProblem.H:414
msrProblem::PowerDensfield
PtrList< volScalarField > PowerDensfield
List of pointers used to form the powerDens snapshots matrix.
Definition msrProblem.H:240
msrProblem::Prec3modes
PtrList< volScalarField > Prec3modes
List of pointers used to form the prec1 modes.
Definition msrProblem.H:276
msrProblem::LP2_matrix
Eigen::MatrixXd LP2_matrix
precursor laplacian term-2
Definition msrProblem.H:424
msrProblem::_p0
autoPtr< volScalarField > _p0
Initial fields (for restart purposes).
Definition msrProblem.H:73
msrProblem::diffusive_term
Eigen::MatrixXd diffusive_term(label NUmodes, label NPmodes)
sub-functions needed by projectPPE
Definition msrProblem.C:507
msrProblem::homboolU
bool homboolU
boolean variables to check if the homogenization of U and T is performed (true) or not (false)
Definition msrProblem.H:522
msrProblem::LD2_matrix
Eigen::MatrixXd LD2_matrix
decay heat laplacian term-2
Definition msrProblem.H:472
msrProblem::Prec7field
PtrList< volScalarField > Prec7field
List of pointers used to form the prec7 snapshots matrix.
Definition msrProblem.H:222
msrProblem::PS8_matrix
Eigen::MatrixXd PS8_matrix
prec_source 8
Definition msrProblem.H:387
msrProblem::MP8_matrix
Eigen::MatrixXd MP8_matrix
precursor mass term-8
Definition msrProblem.H:420
msrProblem::MD2_matrix
Eigen::MatrixXd MD2_matrix
decay heat mass term-2
Definition msrProblem.H:466
msrProblem::liftfieldT
PtrList< volScalarField > liftfieldT
List of pointers used to form the list of lifting functions.
Definition msrProblem.H:515
msrProblem::Dec2modes
PtrList< volScalarField > Dec2modes
List of pointers used to form the dec2 modes.
Definition msrProblem.H:300
msrProblem::restart
void restart()
method to set all fields back to values in 0 folder
Definition msrProblem.C:2016
msrProblem::liftfield
PtrList< volVectorField > liftfield
List of pointers used to form the list of lifting functions.
Definition msrProblem.H:513
msrProblem::PS4_matrix
Eigen::MatrixXd PS4_matrix
prec_source 4
Definition msrProblem.H:379
msrProblem::Pfield
PtrList< volScalarField > Pfield
List of pointers used to form the pressure snapshots matrix.
Definition msrProblem.H:195
msrProblem::MP6_matrix
Eigen::MatrixXd MP6_matrix
precursor mass term-6
Definition msrProblem.H:416
msrProblem::NSFFields
PtrList< volScalarField > NSFFields
List of pointers used to form the NSF snapshosts matrix.
Definition msrProblem.H:249
msrProblem::Prec3field
PtrList< volScalarField > Prec3field
List of pointers used to form the prec3 snapshots matrix.
Definition msrProblem.H:210
msrProblem::Umodes
PtrList< volVectorField > Umodes
List of pointers used to form the velocity modes.
Definition msrProblem.H:264
msrProblem::Dec3modes
PtrList< volScalarField > Dec3modes
List of pointers used to form the dec3 modes.
Definition msrProblem.H:303
msrProblem::Tfield
PtrList< volScalarField > Tfield
List of pointers used to form the temperature snapshots matrix.
Definition msrProblem.H:228
msrProblem::B_matrix
Eigen::MatrixXd B_matrix
Diffusion term.
Definition msrProblem.H:329
msrProblem::Tomfield
PtrList< volScalarField > Tomfield
List of pointers used to form the homogeneous velocity snapshots.
Definition msrProblem.H:519
msrProblem::Ufield
PtrList< volVectorField > Ufield
List of pointers used to form the velocity snapshots matrix.
Definition msrProblem.H:198
msrProblem::Prec1field
PtrList< volScalarField > Prec1field
List of pointers used to form the prec1 snapshots matrix.
Definition msrProblem.H:204
msrProblem::M_matrix
Eigen::MatrixXd M_matrix
Mass Matrix.
Definition msrProblem.H:332
msrProblem::MP4_matrix
Eigen::MatrixXd MP4_matrix
precursor mass term-4
Definition msrProblem.H:412
msrProblem::SPmodes
PtrList< volScalarField > SPmodes
List of pointers used to form the SP snapshosts matrix.
Definition msrProblem.H:318
msrProblem::ST2_matrix
List< Eigen::MatrixXd > ST2_matrix
precursor stream term-2
Definition msrProblem.H:392
msrProblem::FS8_matrix
List< Eigen::MatrixXd > FS8_matrix
precursor flux source term-8
Definition msrProblem.H:452
msrProblem::SPFields
PtrList< volScalarField > SPFields
List of pointers used to form the SP snapshosts matrix.
Definition msrProblem.H:255
msrProblem::msrcoeff
void msrcoeff(label &NC)
method to apply RBF interpolation procedure NC is the number of modes to adopt for construncting the ...
Definition msrProblem.C:1795
msrProblem::PS1_matrix
Eigen::MatrixXd PS1_matrix
prec_source 1
Definition msrProblem.H:373
msrProblem::DFS1_matrix
List< Eigen::MatrixXd > DFS1_matrix
decay heat flux source term-1
Definition msrProblem.H:476
msrProblem::DFS3_matrix
List< Eigen::MatrixXd > DFS3_matrix
decay heat flux source term-3
Definition msrProblem.H:480
msrProblem::homogenizeU
void homogenizeU()
Method to compute the homogenized velocity field, it also sets homboolU=true.
Definition msrProblem.C:1653
msrProblem::stream_dec
List< Eigen::MatrixXd > stream_dec(label NUmodes, label NDecmodes, label decgroup)
decay heat eq. methods:
Definition msrProblem.C:1209
msrProblem::FS5_matrix
List< Eigen::MatrixXd > FS5_matrix
precursor flux source term-5
Definition msrProblem.H:446
msrProblem::projectPPE
void projectPPE(fileName folder, label NUmodes, label NPmodes, label NFluxmodes, Eigen::VectorXi Nprecmodes, label NTmodes, Eigen::VectorXi Ndecmodes, label NCmodes)
Project using the Poisson Equation for pressure.
Definition msrProblem.C:395
msrProblem::THS3_matrix
List< Eigen::MatrixXd > THS3_matrix
temperature decay heat source term-3
Definition msrProblem.H:495
msrProblem::Dec2field
PtrList< volScalarField > Dec2field
List of pointers used to form the dec2 snapshots matrix.
Definition msrProblem.H:234
msrProblem::Prec5field
PtrList< volScalarField > Prec5field
List of pointers used to form the prec5 snapshots matrix.
Definition msrProblem.H:216
msrProblem::LD3_matrix
Eigen::MatrixXd LD3_matrix
decay heat laplacian term-3
Definition msrProblem.H:474
msrProblem::precInBool
bool precInBool
boolean variable to decide if apply prec inlet BC
Definition msrProblem.H:182
msrProblem::C_matrix
List< Eigen::MatrixXd > C_matrix
Non linear term.
Definition msrProblem.H:338
msrProblem::TXSFields
PtrList< volScalarField > TXSFields
List of pointers used to form the SP snapshosts matrix.
Definition msrProblem.H:258
msrProblem::LP5_matrix
Eigen::MatrixXd LP5_matrix
precursor laplacian term-5
Definition msrProblem.H:430
msrProblem::msrgetModesEVD
void msrgetModesEVD()
Method to compute the modes for all the fields in the MSR problem, if hombool==false the velocity mod...
Definition msrProblem.C:223
msrProblem::MD3_matrix
Eigen::MatrixXd MD3_matrix
decay heat mass term-3
Definition msrProblem.H:468
msrProblem::Amodes
PtrList< volScalarField > Amodes
List of pointers used to form the A snapshosts matrix.
Definition msrProblem.H:315
msrProblem::PS2_matrix
Eigen::MatrixXd PS2_matrix
prec_source 2
Definition msrProblem.H:375
msrProblem::Fluxmodes
PtrList< volScalarField > Fluxmodes
List of pointers used to form the flux modes.
Definition msrProblem.H:267
msrProblem::Prec2field
PtrList< volScalarField > Prec2field
List of pointers used to form the prec2 snapshots matrix.
Definition msrProblem.H:207
msrProblem::Dmodes
PtrList< volScalarField > Dmodes
List of pointers used to form the D modes.
Definition msrProblem.H:309
msrProblem::msrgetModesSVD
void msrgetModesSVD()
Method to compute the modes for all the fields in the MSR problem, if hombool==false the velocity mod...
Definition msrProblem.C:151
msrProblem::ST3_matrix
List< Eigen::MatrixXd > ST3_matrix
precursor stream term-3
Definition msrProblem.H:394
msrProblem::PS5_matrix
Eigen::MatrixXd PS5_matrix
prec_source 5
Definition msrProblem.H:381
reductionProblem::writeMu
void writeMu(List< scalar > mu_now)
Write out a list of scalar corresponding to the parameters used in the truthSolve.
Definition reductionProblem.C:242
reductionProblem::mu_samples
Eigen::MatrixXd mu_samples
Matrix of parameters to be used for PODI, where each row corresponds to a sample point....
Definition reductionProblem.H:93
reductionProblem::counter
label counter
Counter used for the output of the full order solutions.
Definition reductionProblem.H:110
reductionProblem::assignBC
void assignBC(volVectorField &s, label BC_ind, Vector< double > &value)
Assign Boundary Condition to a volVectorField.
Definition reductionProblem.C:160
reductionProblem::assignIF
void assignIF(T &s, G &value)
Assign internal field condition.
Definition reductionProblemTemplates.C:34
reductionProblem::computeLift
void computeLift(T &Lfield, T &liftfield, T &omfield)
Homogenize the snapshot matrix, it works with PtrList of volVectorField and volScalarField.
Definition reductionProblemTemplates.C:43
reductionProblem::offline
bool offline
Boolean variable, it is 1 if the Offline phase has already been computed, else 0.
Definition reductionProblem.H:99
reductionProblem::computeLiftT
void computeLiftT(T &Lfield, T &liftfield, T &omfield)
Virtual function to compute the lifting function.
Definition reductionProblemTemplates.C:80
reductionProblem::ITHACAdict
IOdictionary * ITHACAdict
dictionary to store input output infos
Definition reductionProblem.H:101
reductionProblem::mu
Eigen::MatrixXd mu
Row matrix of parameters.
Definition reductionProblem.H:89
reductionProblem::inletIndex
Eigen::MatrixXi inletIndex
Matrix that contains informations about the inlet boundaries.
Definition reductionProblem.H:137
reductionProblem::podex
bool podex
Boolean variable, it is 1 if the POD has already been computed, else 0.
Definition reductionProblem.H:97
reductionProblem::truthSolve
void truthSolve()
Perform a TruthSolve.
Definition reductionProblem.C:97
ITHACAPOD::getModes
void getModes(PtrList< GeometricField< Type, PatchField, GeoMesh > > &snapshots, PtrList< GeometricField< Type, PatchField, GeoMesh > > &modes, word fieldName, bool podex, bool supex, bool sup, label nmodes, bool correctBC)
Computes the bases or reads them for a field.
Definition ITHACAPOD.C:93
ITHACAPOD::getModesSVD
void getModesSVD(PtrList< GeometricField< Type, PatchField, GeoMesh > > &snapshots, PtrList< GeometricField< Type, PatchField, GeoMesh > > &modes, word fieldName, bool podex, bool supex, bool sup, label nmodes, bool correctBC)
Gets the bases for a scalar field using SVD instead of the method of snapshots.
Definition ITHACAPOD.C:858
ITHACAstream::exportMatrix
void exportMatrix(Eigen::Matrix< T, -1, dim > &matrix, word Name, word type, word folder)
Export the reduced matrices in numpy (type=python), matlab (type=matlab) and txt (type=eigen) format ...
Definition ITHACAstream.C:55
ITHACAstream::readMatrix
List< Eigen::MatrixXd > readMatrix(word folder, word mat_name)
Read a three dimensional matrix from a txt file in Eigen format.
Definition ITHACAstream.C:372
ITHACAstream::read_fields
void read_fields(PtrList< GeometricField< Type, PatchField, GeoMesh > > &Lfield, word Name, fileName casename, int first_snap, int n_snap)
Function to read a list of fields from the name of the field and casename.
Definition ITHACAstream.C:517
ITHACAutilities::getCoeffs
Eigen::VectorXd getCoeffs(GeometricField< Type, PatchField, GeoMesh > &snapshot, PtrList< GeometricField< Type, PatchField, GeoMesh > > &modes, label Nmodes, bool consider_volumes)
Projects a snapshot on a basis function and gets the coefficients of the projection.
Definition ITHACAcoeffsMass.C:349
ITHACAutilities::check_pod
bool check_pod()
Check if the POD data folder "./ITHACAoutput/POD" exists.
Definition ITHACAsystem.C:143
ITHACAutilities::check_off
bool check_off()
Check if the offline data folder "./ITHACAoutput/Offline" exists.
Definition ITHACAsystem.C:107
ITHACAutilities::check_folder
bool check_folder(word folder)
Checks if a folder exists.
Definition ITHACAsystem.C:89
Generated by   doxygen 1.16.1