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 nparcels;                                                  
    int realization;                                               
    std::vector<std::shared_ptr<std::vector<double>>> varData;     
 
#ifdef REACTIONS_ENABLED
    std::shared_ptr<Cantera::ThermoPhase> gas;                     
    std::shared_ptr<batchReactor> bRxr;                            
#endif
 
    double domainLength;                                           
    double tau0;                                                   
    double C_param;                                                
    std::vector<double> Temp;                                      
    
private:
    
    int currentIndex = 0;                                          
    int nLevels;                                                   
    int nLevels_;                                                  
    int forceTurb;                                                 
    int nVar;                                                      
    int nsp;                                                       
    int Nm1;                                                       
    int Nm2;                                                       
    int Nm3;                                                       
    int iEta;                                                      
    int nL;                                                        
 
    bool LScHips;                                                  
    bool performReaction;                                          
    bool LrandSet;                                                 
    
    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<int> pLoc;                                         
    std::vector<double> varRho;                                       
    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  approach;
    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;                      
  
 
 
 
public:
 
 
    void set_tree(int nLevels_, double domainLength_, double tau0_, std::vector<double> &ScHips_);  // setting the HiPS tree based on the number of levels
 
  
    void set_tree(double Re_, double domainLength_, double tau0_, std::vector<double> &ScHips_, std::string approach_ = "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. 
    std::vector<std::pair<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 
 
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::pair<std::vector<double>, std::vector<double>> projection_back_with_density(std::vector<double> &vh, 
                                                                                       std::vector<double> &rho_h);
    
 
 
 
    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 writeData(int real, const int ifile, const double outputTime);                                       // Writing the results for a user-defined number of eddies in the data folder.
    void saveAllParameters();                                                                       // Function to save ALL parameters
    
 
 
public:
 
   
    hips(double C_param_,
         int forceTurb_,
         int nVar_,
         bool performReaction,
         std::shared_ptr<void> vcantSol = nullptr,
         int seed = 10,
         int realization_ = 1);
 
 
 
    hips(int nLevels_,
         double domainLength_,
         double tau0_,
         double C_param_,
         int forceTurb_,
         int nVar_,
         std::vector<double> &ScHips_,
         bool performReaction,
         std::shared_ptr<void> vcantSol = nullptr,
         int seed = 10, 
         int realization_ = 1);
 
    void resetForNewRealization() {                                                                 // Reset the number of Index to use for new realization
    currentIndex = 0;
    }
 
};