LCOV - code coverage report
Current view: top level - src/Model/Propellant - Homogenize.H (source / functions) Coverage Total Hit
Test: coverage_merged.info Lines: 2.2 % 45 1
Test Date: 2025-06-26 20:08:28 Functions: 12.5 % 8 1

            Line data    Source code
       1              : //
       2              : // 
       3              : //
       4              : //
       5              : //
       6              : 
       7              : 
       8              : #ifndef MODEL_PROPELLANT_HOMOGENIZE_H
       9              : #define MODEL_PROPELLANT_HOMOGENIZE_H
      10              : 
      11              : #include "Propellant.H"
      12              : 
      13              : namespace Model
      14              : {
      15              : namespace Propellant
      16              : {
      17              : class Homogenize
      18              : {
      19              : public:
      20              :     static constexpr const char* name = "homogenize";
      21              : 
      22            3 :     Homogenize() = default;
      23              :     Homogenize(IO::ParmParse &pp, std::string name) 
      24              :     {
      25              :         pp_queryclass(name,*this);
      26              :     }
      27              : 
      28              :     Set::Scalar P = NAN;
      29            0 :     void set_pressure(const Set::Scalar P) 
      30              :     {
      31            0 :         k4 = h1 * P + h2;
      32            0 :     }
      33              :     
      34            0 :     virtual Set::Scalar get_qdot(const Set::Scalar mdot, const Set::Scalar phi) 
      35              :     {
      36            0 :         Set::Scalar qflux = k4 * phi;
      37            0 :         Set::Scalar mlocal = (mlocal_ap) * massfraction + (mlocal_htpb) * (1.0 - massfraction);
      38            0 :         Set::Scalar mdota = fabs(mdot);
      39            0 :         Set::Scalar mbase = tanh(4.0 * mdota / (mlocal));
      40            0 :         return  mbase * qflux;
      41              :     }
      42              : 
      43            0 :     Set::Scalar get_K (const Set::Scalar phi)
      44              :     {
      45            0 :         return (k_ap * massfraction + k_htpb * (1.0 - massfraction)) * phi + dispersion1 * (1. - phi);
      46              :     }
      47              : 
      48            0 :     Set::Scalar get_rho (const Set::Scalar phi)
      49              :     {
      50              : 
      51            0 :         return (rho_ap * massfraction + rho_htpb * (1.0 - massfraction)) * phi + dispersion2 * (1. - phi); 
      52              :     }
      53              : 
      54            0 :     Set::Scalar get_cp (const Set::Scalar phi)
      55              :     {
      56            0 :         return (cp_ap * massfraction + cp_htpb * (1.0 - massfraction)) * phi + dispersion3 * (1. - phi);
      57              :     }
      58              : 
      59            0 :     Set::Scalar get_L (Set::Scalar phi, Set::Scalar T) 
      60              :     {
      61            0 :         Set::Scalar L = NAN;
      62            0 :         if (mob_ap == 1) L = m_ap * P * exp(-E_ap / T) * phi;
      63            0 :         else L = m_ap * exp(-E_ap / T) * phi;
      64            0 :         L += m_htpb * exp(-E_htpb / T) * (1.0 - phi);
      65            0 :         if (T <= bound) L = 0.0;
      66            0 :         return L;
      67              :     }
      68              : 
      69              : 
      70            0 :     static void Parse(Homogenize& value, IO::ParmParse& pp)
      71              :     {
      72              :         
      73              :         // K; dispersion variables are use to create an inert region for the void grain case. 
      74              :         // An inert region is one that dissipates energy fast enough to remove regression and 
      75              :         // thermal strain effects.
      76            0 :         pp_query("dispersion1", value.dispersion1);
      77              :         // rho; dispersion variables are use to create an inert region for the void grain case. 
      78              :         // An inert region is one that dissipates energy fast enough to remove regression and 
      79              :         // thermal strain effects.
      80            0 :         pp_query("dispersion2", value.dispersion2);
      81              :         // cp; dispersion variables are use to create an inert region for the void grain case. 
      82              :         // An inert region is one that dissipates energy fast enough to remove regression and 
      83              :         // thermal strain effects.
      84            0 :         pp_query("dispersion3", value.dispersion3); 
      85              : 
      86              : 
      87              :         // AP Density
      88            0 :         pp_query_required("rho_ap", value.rho_ap);
      89              :         // HTPB Density
      90            0 :         pp_query_required("rho_htpb", value.rho_htpb);
      91              :         // AP Thermal Conductivity
      92            0 :         pp_query_required("k_ap", value.k_ap);
      93              :         // HTPB Thermal Conductivity
      94            0 :         pp_query_required("k_htpb", value.k_htpb);
      95              :         // AP Specific Heat
      96            0 :         pp_query_required("cp_ap", value.cp_ap);
      97              :         //HTPB Specific Heat
      98            0 :         pp_query_required("cp_htpb", value.cp_htpb); 
      99              : 
     100              : 
     101              :         // Surgate heat flux model paramater - Homogenized
     102            0 :         pp_query_default("h1", value.h1, 1.81); 
     103              :         // Surgate heat flux model paramater - Homogenized
     104            0 :         pp_query_default("h2", value.h2, 1.34); 
     105              : 
     106              :         // AP/HTPB ratio for homogenized domain
     107            0 :         pp_query_default("massfraction", value.massfraction, 0.8);
     108              : 
     109              :         // AP mass flux reference value 
     110            0 :         pp_query_default("mlocal_ap", value.mlocal_ap, 0.0); 
     111            0 :         value.mlocal_htpb = 685000.0 - 850e3 * value.massfraction;
     112              :         
     113              :         // AP Pre-exponential factor for Arrhenius Law
     114            0 :         pp_query_required("m_ap", value.m_ap); 
     115              :         // HTPB Pre-exponential factor for Arrhenius Law
     116            0 :         pp_query_required("m_htpb", value.m_htpb); 
     117              :         // AP Activation Energy for Arrhenius Law
     118            0 :         pp_query_required("E_ap", value.E_ap); 
     119              :         // HTPB Activation Energy for Arrhenius Law
     120            0 :         pp_query_required("E_htpb", value.E_htpb); 
     121              :         // Whether to include pressure to the arrhenius law [??]
     122            0 :         pp_query_default("mob_ap", value.mob_ap,0); 
     123              :         // HTPB Activation Energy for Arrhenius Law
     124            0 :         pp_query_default("bound", value.bound,0.0); 
     125            0 :     }
     126              : 
     127              :     // IO variables
     128              :     Set::Scalar massfraction = NAN;
     129              :     Set::Scalar dispersion1 = NAN, dispersion2 = NAN, dispersion3 = NAN;
     130              :     Set::Scalar k_ap = NAN, k_htpb = NAN;
     131              :     Set::Scalar rho_ap = NAN, rho_htpb = NAN;
     132              :     Set::Scalar cp_ap = NAN, cp_htpb = NAN;
     133              :     Set::Scalar h1 = NAN, h2=NAN;
     134              :     Set::Scalar mlocal_ap = NAN;
     135              :     // Regression variables
     136              :     int mob_ap = -1;
     137              :     Set::Scalar m_ap = NAN, m_htpb = NAN, m_comb = NAN;
     138              :     Set::Scalar E_ap = NAN, E_htpb = NAN;
     139              :     Set::Scalar bound = NAN;
     140              : 
     141              :     // Calculated variables
     142              :     Set::Scalar k4 = NAN;
     143              :     Set::Scalar mlocal_htpb = NAN;
     144              : };
     145              : 
     146              : }
     147              : }
     148              : 
     149              : 
     150              : 
     151              : #endif
     152              : 
     153              : 
        

Generated by: LCOV version 2.0-1