hips.h

Go to the documentation of this file.

#pragma once
 
#ifdef  REACTIONS_ENABLED
#include "cantera/base/Solution.h"
#include "cantera/thermo.h"
#include "batchReactor.h"
#endif
 
#include <iostream>
#include <vector>
#include <string>
#include <vector>
#include <memory>
#include "randomGenerator.h"
 
class hips {
 
 
public:
  
    int realization;                                               
    std::vector<std::shared_ptr<std::vector<double>>> varData;     
    std::vector<double> varRho;                                    
    std::vector<int> pLoc;                                         
    std::vector<double> wPar;                                      
 
 
#ifdef REACTIONS_ENABLED
    std::shared_ptr<Cantera::ThermoPhase> gas;                     
    std::shared_ptr<batchReactor> bRxr;                            
#endif
 
    double domainLength;                                           
    double tau0;                                                   
    double C_param;                                                
    
private:
 
    int nparcels;                                                  
    int currentIndex = 0;                                          
    int nLevels;                                                   
    int nLevels_;                                                  
    int nVar;                                                      
    int nsp;                                                       
    int Nm1;                                                       
    int Nm2;                                                       
    int Nm3;                                                       
    int iEta;                                                      
    int nL;                                                        
    bool forceTurb;                                                
 
    bool LScHips;                                                  
    bool performReaction;                                          
        
    double time;                                                   
    double eddyRate_total;                                         
    double eddyRate_inertial;                                      
    double Afac = 0.5;                                             
    double Re;                                                     
    double dtEE;                                                   
    double Prob;                                                   
    double lStar;                                                  
    double Anew;                                                   
 
    randomGenerator rand;                                               
    
    std::vector<int> i_plus;                                       
    std::vector<double> ScHips;                                    
    std::vector<std::string> varName;                              
    std::vector<double> parcelTimes;                               
    std::vector<double> levelRates;                                
    std::vector<double> i_batchelor;                               
    std::vector<double> xc;                                        
    std::vector<double> xh;                                        
    
    std::string  ReApproach;
    int outputIntervalEddy = 10;                                   
    double outputIntervalTime = 0.1;                               
    int eddyCounter = 0;                                           
    double lastOutputTime = 0.0;                                   
    bool useEddyBasedWriting = false;                              
    bool useTimeBasedWriting = false;                              
    const int DEFAULT_EDDY_INTERVAL = 1000;                        
    const double DEFAULT_TIME_INTERVAL = 0.1;                      
    //bool density_weighted_mixing = false;                          ///< default: simple (uniform) mixing
 
   
 
 
public:
 
 
    void set_tree(int nLevels_, double domainLength_, double tau0_);  // setting the HiPS tree based on the number of levels
 
 
  
    void set_tree(double Re_, double domainLength_, double tau0_, std::string ReApproach_ = "rounding");
  
 
    void set_varData(std::vector<double> &v, std::vector<double> &w, const std::string &varN);      // passing all variables to vector of pointer 
    void set_varData(std::vector<double> &v, std::vector<double> &w, const std::string &varN,
                     const std::vector<double> &rho);                                               // passing all variables to vector of pointer
 
    std::vector<std::vector<double>> get_varData();                                                 // Retrieves modified data from the HiPS library and stores it in the provided vector, projection to CFD
    std::pair<std::vector<std::vector<double>>, std::vector<double>> get_varData_with_density();
   
    void setOutputIntervalTime(double interval);
    void setOutputIntervalEddy(int interval);
 
    void calculateSolution(const double tRun, bool shouldWriteData =false);                         // Running simulations 
 
    void writeData(int real, const int ifile, const double outputTime);                                       // Writing the results for a user-defined number of eddies in the data folder.
    int get_nparcels() const { return nparcels; }
    
    const std::vector<int>& get_pLoc() const { return pLoc; }
    const std::vector<std::shared_ptr<std::vector<double>>>& get_HipsVarData_ptr() const { return varData; } // internal HiPS varData, sized to nparcels
 
 
 
 
private:
 
    std::vector<double> projection(std::vector<double> &vcfd, std::vector<double> &weight);         // Perform vector projection of flow particles onto hips parcels operation without density 
    
    std::pair<std::vector<double>, std::vector<double>>  projection(std::vector<double> &vcfd, std::vector<double> &weight,                     
                                   const std::vector<double> &density);                             // Perform vector projection flow particles onto hips parcels operation with density 
    
    std::vector<double> setGridHips(int N);                                                         // Set Hips grid with a specified number of grid points equal to number of parcels   
    std::vector<double> setGridCfd(std::vector<double> &w);                                         // Set CFD grid using provided weight vector
    std::vector<double> projection_back(std::vector<double> &vb);                       
    std::vector<double> projection_back_with_density(std::vector<double> &vh, 
                                                     std::vector<double> &rho_h,
                                                     std::vector<double> &rho_c);
    
 
 
 
    void sample_hips_eddy(double &dt, int &iLevel);                                                 // Sample hips eddy with specified time step and level                                                
    void selectAndSwapTwoSubtrees(const int iLevel, int &iTree);                                    // Select and swap two subtrees in the level tree
    void advanceHips(const int iLevel, const int iTree);                                            // Advancing simulations to do mixing and reaction
   
    int getVariableIndex(const std::string &varName) const;
 
    void reactParcels_LevelTree(const int iLevel, const int iTree);                                 // Reacting parcels involved in micro-mixing
    void mixAcrossLevelTree(int kVar, const int iMixLevel, const int iTree);                        // Mixing paecels involved in micr0-mixing.
   
    void forceProfile();
    
    void saveAllParameters();                                                                       // Function to save ALL parameters
    
 
 
public:
 
   
    hips(double C_param_,
         bool forceTurb_,
         int nVar_,
         std::vector<double> &ScHips_,
         bool performReaction,
         std::shared_ptr<void> vcantSol = nullptr,
         int seed = 10,
         int realization_ = 1);
 
 
 
    hips(int nLevels_,
         double domainLength_,
         double tau0_,
         double C_param_,
         bool forceTurb_,
         int nVar_,
         std::vector<double> &ScHips_,
         bool performReaction,
         std::shared_ptr<void> vcantSol = nullptr,
         int seed = 10, 
         int realization_ = 1);
 
};