msrProblem.H

Go to the documentation of this file.

#ifndef msrProblem_H
#define msrProblem_H
#include "fvCFD.H"
#include "singlePhaseTransportModel.H"
#include "turbulentTransportModel.H"
#include "simpleControl.H"
#include "pisoControl.H"
#include "fvOptions.H"
#include "reductionProblem.H"
#include "ITHACAstream.H"
#include "ITHACAforces.H"
#include "volFields.H"
#include <iostream>
#include "IOmanip.H"
#include "IFstream.H"
#include "primitiveFields.H"
#include "FieldFields.H"
#include "scalarMatrices.H"
#include "SortableList.H"
#include "volFieldsFwd.H"
#include "forces.H"
#include "forceCoeffs.H"
#include "volFields.H"
#include <fstream>
#include <sstream>
#include <vector>
#include <string>
#include <stdio.h>
#include "ITHACAPOD.H"
#include <math.h>
 
 
 
class msrProblem: public reductionProblem
{
 
    public:
        //Constructors
        msrProblem();
        msrProblem(int argc, char* argv[]);
        ~msrProblem() {};
 
        // Dummy variables to transform msrFoam into a class, createTime.H
 
        autoPtr<Time> _runTime;
 
        // Dummy variables to transform msrFoam into a class, createMesh.H
 
        mutable autoPtr<fvMesh> _mesh;
 
        // Dummy variables to transform msrFoam into a class, createFields.H
 
        autoPtr<volVectorField> _U;
        autoPtr<surfaceScalarField> _phi;
        autoPtr<singlePhaseTransportModel> _laminarTransport;
        autoPtr<incompressible::turbulenceModel> turbulence;
        autoPtr<IOMRFZoneList> _MRF;
        autoPtr<volScalarField> _p;
        label pRefCell;
        scalar pRefValue;
        autoPtr<dimensionedScalar> _nu;
        autoPtr<dimensionedScalar> _Pr;
        autoPtr<dimensionedScalar> _Prt;
        autoPtr<dimensionedScalar> _rhoRef;
        autoPtr<volScalarField> _v;
        autoPtr<dimensionedScalar> _CpRef;
        autoPtr<dimensionedScalar> _Tref;
        autoPtr<dimensionedScalar> _TrefXS;
        autoPtr<volScalarField> _TXS;
        autoPtr<volScalarField> _p0;
        autoPtr<volVectorField> _U0;
        autoPtr<surfaceScalarField> _phi0;
        autoPtr<volScalarField> _flux0;
        autoPtr<volScalarField> _prec10;
        autoPtr<volScalarField> _prec20;
        autoPtr<volScalarField> _prec30;
        autoPtr<volScalarField> _prec40;
        autoPtr<volScalarField> _prec50;
        autoPtr<volScalarField> _prec60;
        autoPtr<volScalarField> _prec70;
        autoPtr<volScalarField> _prec80;
        autoPtr<volScalarField> _T0;
        autoPtr<volScalarField> _dec10;
        autoPtr<volScalarField> _dec20;
        autoPtr<volScalarField> _dec30;
        autoPtr<dimensionedScalar> _K0;
        autoPtr<volScalarField> _v0;
        autoPtr<volScalarField> _NSF0;
        autoPtr<volScalarField> _A0;
        autoPtr<volScalarField> _D0;
        autoPtr<volScalarField> _SP0;
        autoPtr<volScalarField> _TXS0;
 
 
        // Dummy variables to transform msrFoam into a class, createFields_neutronics.H
 
        autoPtr<dimensionedScalar> _Keff;
        autoPtr<dimensionedScalar> _IV1;
        autoPtr<dimensionedScalar> _D1_0;
        autoPtr<volScalarField> _D;
        autoPtr<dimensionedScalar> _alfa_D1;
        autoPtr<dimensionedScalar> _A1_0;
        autoPtr<volScalarField> _A;
        autoPtr<dimensionedScalar> _alfa_A1;
        autoPtr<dimensionedScalar> _NSF1_0;
        autoPtr<volScalarField> _NSF;
        autoPtr<dimensionedScalar> _alfa_NSF1;
        autoPtr<dimensionedScalar> _SP1_0;
        autoPtr<volScalarField> _SP;
        autoPtr<dimensionedScalar> _alfa_SP1;
        autoPtr<dimensionedScalar> _lam1;
        autoPtr<dimensionedScalar> _lam2;
        autoPtr<dimensionedScalar> _lam3;
        autoPtr<dimensionedScalar> _lam4;
        autoPtr<dimensionedScalar> _lam5;
        autoPtr<dimensionedScalar> _lam6;
        autoPtr<dimensionedScalar> _lam7;
        autoPtr<dimensionedScalar> _lam8;
        autoPtr<dimensionedScalar> _beta1;
        autoPtr<dimensionedScalar> _beta2;
        autoPtr<dimensionedScalar> _beta3;
        autoPtr<dimensionedScalar> _beta4;
        autoPtr<dimensionedScalar> _beta5;
        autoPtr<dimensionedScalar> _beta6;
        autoPtr<dimensionedScalar> _beta7;
        autoPtr<dimensionedScalar> _beta8;
        autoPtr<dimensionedScalar> _betaTot;
        autoPtr<volScalarField> _flux;
        autoPtr<dimensionedScalar> _decLam1;
        autoPtr<dimensionedScalar> _decLam2;
        autoPtr<dimensionedScalar> _decLam3;
        autoPtr<dimensionedScalar> _decBeta1;
        autoPtr<dimensionedScalar> _decBeta2;
        autoPtr<dimensionedScalar> _decBeta3;
        autoPtr<dimensionedScalar> _decbetaTot;
        autoPtr<dimensionedScalar> _betaTE;
        autoPtr<volScalarField> _prec1;
        autoPtr<volScalarField> _prec2;
        autoPtr<volScalarField> _prec3;
        autoPtr<volScalarField> _prec4;
        autoPtr<volScalarField> _prec5;
        autoPtr<volScalarField> _prec6;
        autoPtr<volScalarField> _prec7;
        autoPtr<volScalarField> _prec8;
        autoPtr<dimensionedScalar> _Sc;
        autoPtr<dimensionedScalar> _Sct;
        autoPtr<volScalarField> _alphat;
        autoPtr<volScalarField> _difft;
 
        //recirculation time
        double tau;
 
 
        // Dummy variables to transform msrFoam into a class, createFields_T.H
 
        autoPtr<volScalarField> _T;
        autoPtr<volScalarField> _logT;
        autoPtr<volScalarField> _dec1;
        autoPtr<volScalarField> _dec2;
        autoPtr<volScalarField> _dec3;
 
        // Dummy variables to transform msrFoam into a class, createFvOptions.H
 
        autoPtr<fv::options> _fvOptions;
 
        // Dummy variables to transform msrFoam into a class, remaining in .C
 
        autoPtr<simpleControl> _simple;
        scalar tolerance;
        scalar maxIter;
        scalar cumulativeContErr = 0;
 
        bool precInBool = false;
        label precinIndex;
        label precoutIndex;
        Eigen::MatrixXd bc_prec;
 
 
 
 
        // Fields containing the offline solution i.e. the snapshot matrix
 
        PtrList<volScalarField> Pfield;
 
        PtrList<volVectorField> Ufield;
 
        PtrList<volScalarField> Fluxfield;
 
        PtrList<volScalarField> Prec1field;
 
        PtrList<volScalarField> Prec2field;
 
        PtrList<volScalarField> Prec3field;
 
        PtrList<volScalarField> Prec4field;
 
        PtrList<volScalarField> Prec5field;
 
        PtrList<volScalarField> Prec6field;
 
        PtrList<volScalarField> Prec7field;
 
        PtrList<volScalarField> Prec8field;
 
        PtrList<volScalarField> Tfield;
 
        PtrList<volScalarField> Dec1field;
 
        PtrList<volScalarField> Dec2field;
 
        PtrList<volScalarField> Dec3field;
 
        PtrList<volScalarField> PowerDensfield;
 
        PtrList<volScalarField> vFields;
 
        PtrList<volScalarField> DFields;
 
        PtrList<volScalarField> NSFFields;
 
        PtrList<volScalarField> AFields;
 
        PtrList<volScalarField> SPFields;
 
        PtrList<volScalarField> TXSFields;
 
        PtrList<volScalarField> Pmodes;
 
        PtrList<volVectorField> Umodes;
 
        PtrList<volScalarField> Fluxmodes;
 
        PtrList<volScalarField> Prec1modes;
 
        PtrList<volScalarField> Prec2modes;
 
        PtrList<volScalarField> Prec3modes;
 
        PtrList<volScalarField> Prec4modes;
 
        PtrList<volScalarField> Prec5modes;
 
        PtrList<volScalarField> Prec6modes;
 
        PtrList<volScalarField> Prec7modes;
 
        PtrList<volScalarField> Prec8modes;
 
        PtrList<volScalarField> Tmodes;
 
        PtrList<volScalarField> Dec1modes;
 
        PtrList<volScalarField> Dec2modes;
 
        PtrList<volScalarField> Dec3modes;
 
        PtrList<volScalarField> vmodes;
 
        PtrList<volScalarField> Dmodes;
 
        PtrList<volScalarField> NSFmodes;
 
        PtrList<volScalarField> Amodes;
 
        PtrList<volScalarField> SPmodes;
 
        PtrList<volScalarField> TXSmodes;
 
        //----------------------------------------------------------------------//
        // Coefficient matrices:
 
        //Fluid-dynamics matrices:
 
        Eigen::MatrixXd B_matrix;
 
        Eigen::MatrixXd M_matrix;
 
        Eigen::MatrixXd K_matrix;
 
        List <Eigen::MatrixXd> C_matrix;
 
        Eigen::MatrixXd P_matrix;
 
        Eigen::MatrixXd D_matrix;
 
        List <Eigen::MatrixXd> G_matrix;
 
        Eigen::MatrixXd BC1_matrix;
 
        List <Eigen::MatrixXd> BC2_matrix;
 
        Eigen::MatrixXd BC3_matrix;
 
 
        //Neutronics matrices:
 
        List<Eigen::MatrixXd> LF_matrix;
        Eigen::MatrixXd MF_matrix;
        List<Eigen::MatrixXd> PF_matrix;
        List<Eigen::MatrixXd> AF_matrix;
 
        ITHACAparameters* para;
 
        Eigen::MatrixXd PS1_matrix;
        Eigen::MatrixXd PS2_matrix;
        Eigen::MatrixXd PS3_matrix;
        Eigen::MatrixXd PS4_matrix;
        Eigen::MatrixXd PS5_matrix;
        Eigen::MatrixXd PS6_matrix;
        Eigen::MatrixXd PS7_matrix;
        Eigen::MatrixXd PS8_matrix;
 
        List<Eigen::MatrixXd> ST1_matrix;
        List<Eigen::MatrixXd> ST2_matrix;
        List<Eigen::MatrixXd> ST3_matrix;
        List<Eigen::MatrixXd> ST4_matrix;
        List<Eigen::MatrixXd> ST5_matrix;
        List<Eigen::MatrixXd> ST6_matrix;
        List<Eigen::MatrixXd> ST7_matrix;
        List<Eigen::MatrixXd> ST8_matrix;
        Eigen::MatrixXd MP1_matrix;
        Eigen::MatrixXd MP2_matrix;
        Eigen::MatrixXd MP3_matrix;
        Eigen::MatrixXd MP4_matrix;
        Eigen::MatrixXd MP5_matrix;
        Eigen::MatrixXd MP6_matrix;
        Eigen::MatrixXd MP7_matrix;
        Eigen::MatrixXd MP8_matrix;
        Eigen::MatrixXd LP1_matrix;
        Eigen::MatrixXd LP2_matrix;
        Eigen::MatrixXd LP3_matrix;
        Eigen::MatrixXd LP4_matrix;
        Eigen::MatrixXd LP5_matrix;
        Eigen::MatrixXd LP6_matrix;
        Eigen::MatrixXd LP7_matrix;
        Eigen::MatrixXd LP8_matrix;
        List<Eigen::MatrixXd> FS1_matrix;
        List<Eigen::MatrixXd> FS2_matrix;
        List<Eigen::MatrixXd> FS3_matrix;
        List<Eigen::MatrixXd> FS4_matrix;
        List<Eigen::MatrixXd> FS5_matrix;
        List<Eigen::MatrixXd> FS6_matrix;
        List<Eigen::MatrixXd> FS7_matrix;
        List<Eigen::MatrixXd> FS8_matrix;
 
 
        //Energy matrices:
 
        List<Eigen::MatrixXd> SD1_matrix;
        List<Eigen::MatrixXd> SD2_matrix;
        List<Eigen::MatrixXd> SD3_matrix;
        Eigen::MatrixXd MD1_matrix;
        Eigen::MatrixXd MD2_matrix;
        Eigen::MatrixXd MD3_matrix;
        Eigen::MatrixXd LD1_matrix;
        Eigen::MatrixXd LD2_matrix;
        Eigen::MatrixXd LD3_matrix;
        List<Eigen::MatrixXd> DFS1_matrix;
        List<Eigen::MatrixXd> DFS2_matrix;
        List<Eigen::MatrixXd> DFS3_matrix;
 
        Eigen::MatrixXd TM_matrix;
        List<Eigen::MatrixXd> TS_matrix;
        Eigen::MatrixXd LT_matrix;
        List<Eigen::MatrixXd> TXS_matrix;
        List<Eigen::MatrixXd> THS1_matrix;
        List<Eigen::MatrixXd> THS2_matrix;
        List<Eigen::MatrixXd> THS3_matrix;
        //--------------------------------------------------------------------------------//
 
 
        label NUmodes;
        label NPmodes;
        label NFluxmodes;
        Eigen::VectorXi NPrecmodes;
        Eigen::VectorXi NDecmodes;
        label NTmodes;
        label NCmodes;
 
 
        //--------------------------------------------------------------------------------//
        //Lift-functions and homogenization related terms:
 
        PtrList<volVectorField> liftfield;
        PtrList<volScalarField> liftfieldT;
        PtrList<volVectorField> Uomfield;
        PtrList<volScalarField> Tomfield;
        bool homboolU = false;
        bool homboolT = false;
 
        //-----------------------------------------------------------------------------//
        //RBF interpolation procedure quantities, i.e. constants changing with
        //temperature
 
        // Create a SAMPLES for interpolation
        std::vector<SPLINTER::DataTable*> SAMPLES_v;
        // Create a SAMPLES for interpolation
        std::vector<SPLINTER::DataTable*> SAMPLES_D;
        // Create a SAMPLES for interpolation
        std::vector<SPLINTER::DataTable*> SAMPLES_NSF;
        // Create a SAMPLES for interpolation
        std::vector<SPLINTER::DataTable*> SAMPLES_A;
        // Create a SAMPLES for interpolation
        std::vector<SPLINTER::DataTable*> SAMPLES_SP;
        // Create a SAMPLES for interpolation
        std::vector<SPLINTER::DataTable*> SAMPLES_TXS;
        // Create a RBF splines for interpolation
        std::vector<SPLINTER::RBFSpline*> rbfsplines_v;
        // Create a RBF splines for interpolation
        std::vector<SPLINTER::RBFSpline*> rbfsplines_D;
        // Create a RBF splines for interpolation
        std::vector<SPLINTER::RBFSpline*> rbfsplines_NSF;
        // Create a RBF splines for interpolation
        std::vector<SPLINTER::RBFSpline*> rbfsplines_A;
        // Create a RBF splines for interpolation
        std::vector<SPLINTER::RBFSpline*> rbfsplines_SP;
        // Create a RBF splines for interpolation
        std::vector<SPLINTER::RBFSpline*> rbfsplines_TXS;
 
        //-----------------------------------------------------------------------------------------//
        // Methods:
 
        void truthSolve(List<scalar> mu_now);
        //----------------------------------------------------------------------------------
 
        void msrcoeff(label& NC);
        //----------------------------------------------------------------------------------
 
        void liftSolve();
        //----------------------------------------------------------------------------------
 
        void liftSolveT();
        //----------------------------------------------------------------------------------
 
        void readMSRfields();
        void readMSRfields(std::string& dir);
        //-----------------------------------------------------------------------------------
 
        void homogenizeU();
        //-----------------------------------------------------------------------------------
 
        void homogenizeT();
        //--------------------------------------------------------------------------
 
        void msrgetModesSVD();
        //--------------------------------------------------------------------------
 
        void msrgetModesEVD();
        //--------------------------------------------------------------------------
 
        void projectPPE(fileName folder, label NUmodes, label NPmodes, label NFluxmodes,
                        Eigen::VectorXi Nprecmodes, label NTmodes, Eigen::VectorXi Ndecmodes,
                        label NCmodes);
        //--------------------------------------------------------------------------
 
 
        Eigen::MatrixXd diffusive_term(label NUmodes, label NPmodes);
        Eigen::MatrixXd pressure_gradient_term(label NUmodes, label NPmodes);
        List < Eigen::MatrixXd > convective_term(label NUmodes, label NPmodes);
        Eigen::MatrixXd mass_term(label NUmodes, label NPmodes);
 
        Eigen::MatrixXd divergence_term(label NUmodes, label NPmodes);
        List < Eigen::MatrixXd > div_momentum(label NUmodes, label NPmodes);
        Eigen::MatrixXd laplacian_pressure(label NPmodes);
        Eigen::MatrixXd pressure_BC1(label NUmodes, label NPmodes);
        List < Eigen::MatrixXd > pressure_BC2(label NUmodes, label NPmodes);
        Eigen::MatrixXd pressure_BC3(label NUmodes, label NPmodes);
 
        List<Eigen::MatrixXd> laplacian_flux(label NFluxmodes, label NCmodes);
        Eigen::MatrixXd mass_flux(label NFluxmodes);
        List<Eigen::MatrixXd> prod_flux(label NFluxmodes, label NCmodes);
        List<Eigen::MatrixXd> abs_flux(label NFluxmodes, label NCmodes);
        Eigen::MatrixXd prec_source(label NFluxmodes, label NPrecmodes, label family);
 
        List<Eigen::MatrixXd> stream_term(label NUmodes, label NPrecmodes,
                                          label family);
        Eigen::MatrixXd prec_mass(label NPrecmodes, label family);
        Eigen::MatrixXd laplacian_prec(label NPrecmodes, label family);
        List<Eigen::MatrixXd> flux_source(label NFluxmodes, label NPrecmodes,
                                          label NCmodes, label family);
 
        List<Eigen::MatrixXd> stream_dec(label NUmodes, label NDecmodes,
                                         label decgroup);
        Eigen::MatrixXd dec_mass(label NDecmodes, label decgroup);
        Eigen::MatrixXd laplacian_dec(label NDecmodes, label decgroup);
        List<Eigen::MatrixXd> dec_fluxsource(label NFluxmodes, label NDecmodes,
                                             label NCmodes, label decgroup);
 
        Eigen::MatrixXd mass_temp(label NTmodes);
        List<Eigen::MatrixXd> temp_stream(label NUmodes, label NTmodes);
        Eigen::MatrixXd laplacian_temp(label NTmodes);
        List<Eigen::MatrixXd> temp_heatsource(label NTmodes, label NDecmodes,
                                              label NCmodes, label decgroup);
        List<Eigen::MatrixXd> temp_XSfluxsource(label NTmodes, label NFluxmodes,
                                                label NCmodes);
 
        //--------------------------------------------------------------------------
        void change_viscosity(double mu);
 
        //--------------------------------------------------------------------------
        void restart();
 
 
 
    protected:
 
        //--------------------------------------------------------------------------
 
        PtrList<volScalarField> choose_group(string field, label ith);
 
        //--------------------------------------------------------------------------
 
        template<typename M>
        void savegroupMatrix(string nome, label n, word folder, M matrice);
 
 
 
};
 
#endif