ignis.h

Go to the documentation of this file.

#pragma once
 
#include "cantera/base/Solution.h"
#include "cantera/thermo.h"
#include "cantera/kinetics.h"
#include "cantera/transport.h"
#include "streams.h"
#include "rad_planck_mean.h"
#include "rad_rcslw.h"
#include "rad_wsgg.h"
#include "linearInterp.h"
#include "sootHeaders.h"
 
#include <highfive/highfive.hpp>
 
#include <vector>
#include <memory>
#include <string>
 
 
class ignis {
 
public:
 
    size_t ngrd;                                    
    size_t nsp;                                     
    size_t nsoot;                                   
    size_t nvar;                                    
    size_t nvarA;                                   
 
    double                            P;            
    std::vector<std::vector<double> > y;            
    std::vector<double>               T;            
    std::vector<std::vector<double> > sootvars;     
 
    double                            Pstore;       
    std::vector<std::vector<double> > ystore;       
    std::vector<double>               Tstore;       
    std::vector<std::vector<double> > sootstore;    
 
    std::vector<double> yLbc, yRbc;                 
    double TLbc, TRbc;                              
    double hLbc, hRbc;                              
    double cpLbc,cpRbc;                             
    std::vector<double> hspLbc;                     
    std::vector<double> hspRbc;                     
 
    double              L;                          
    std::vector<double> x;                          
    std::vector<double> dx;                         
    std::vector<double> fl;                         
    std::vector<double> fr;                         
 
    double Tscale;                                  
    double hscale;                                  
    std::vector<double> sootScales;                 
 
    std::vector<double> vars0;                      
    std::vector<double> F0;                         
    double s;                                       
 
    std::shared_ptr<Cantera::ThermoPhase> gas;      
    std::shared_ptr<Cantera::Kinetics>    kin;      
    std::shared_ptr<Cantera::Transport>   trn;      
 
    std::shared_ptr<streams> strm;                  
    std::shared_ptr<rad> radProps;                  
    std::string          radType;                   
    bool doRadiation;                               
    std::vector<double> kabs_sur;                   
    std::vector<double> awts_sur;                   
 
    bool doLe1 = false;                             
 
    double Ttarget;                                 
    double dT;                                      
    int isave;                                      
 
    std::vector<std::vector<double> > flux_y;       
    std::vector<std::vector<double> > flux_soot;    
    std::vector<double>               flux_h;       
 
    bool isFlamelet = false;                        
    std::vector<double> chi;                        
    double chi0;
 
    bool   isPremixed = false;                      
    double mflux = 0.0;                             
 
    bool doEnergyEqn = true;                        
    std::shared_ptr<linearInterp> LI;               
    std::vector<double> Tprof_h;                    
    std::vector<double> Tprof_T;                    
 
    //---------------------
 
    bool doSoot = false;                            
    std::shared_ptr<soot::sootModel> SM;            
    std::shared_ptr<soot::state>     SMstate;       
 
    //---------------------
 
    std::shared_ptr<HighFive::File> fh5;            
 
 
    void setIC(const std::string icType, const std::string fname="");
    void storeState();
    void setFluxesUnity();
    void setFluxes();
    void setGrid(double _L);
    void writeFileHdf5(const std::string gname, const std::string timeType);
    void writeFile(const std::string fname);
    void solveSS();
    void setChi(const double _chi0);
    void solveUnsteady(const double nTauRun, const int nsteps, const bool doWriteTime=true, 
                       const double Tmin=0, const double Tmax=0);
    int  Func(const double *vars, double *F);
    int  rhsf(const double *vars, double *dvarsdt);
    int  rhsf_flamelet(const double *vars, double *dvarsdt);
    void setQrad(std::vector<double> &Q);
    void setTprof(const std::vector<double> &_Tprof_h, const std::vector<double> &_Tprof_T) {
        Tprof_h = _Tprof_h;
        Tprof_T = _Tprof_T;
        LI = std::make_shared<linearInterp>(Tprof_h, Tprof_T);
    }
    void setDerivative2(const double vL, const double vR, 
                        const std::vector<double> &v, 
                        std::vector<double> &d2vdx2);
    void setDerivative( const double vL, const double vR, 
                        const std::vector<double> &v, 
                        std::vector<double> &dvdx);
 
    size_t I( size_t i, size_t k) { return i*nsp  + k; }     // y[I(i,k)] in 1D --> y[i,k] in 2D
    size_t Ia(size_t i, size_t k) { return i*nvar + k; }     // for indexing combined (a for all) vars
 
 
    ignis(const bool _isPremixed, const bool _doEnergyEqn, const bool _isFlamelet, const bool _doSoot, 
          const size_t _ngrd, const double _L, const double _P,
          std::shared_ptr<Cantera::Solution> csol, std::string _radType,
          const std::vector<double> &_yLbc, const std::vector<double> &_yRbc, 
          const double _TLbc, const double _TRbc,
          std::shared_ptr<soot::sootModel> _SM, 
          std::shared_ptr<soot::state>     _SMstate);
 
};