Line data    Source code

       1              : //
       2              : // This SCP model implements the method described in the following paper
       3              : //
       4              : // .. bibliography::
       5              : //    :list: none
       6              : //    :filter: False
       7              : // 
       8              : //    kanagarajan2022diffuse
       9              : //
      10              : // This method imitates inheritance :code:`Propellant::Propellant` using static polymorphism
      11              : // 
      12              : 
      13              : #ifndef MODEL_PROPELLANT_POWERLAW_H
      14              : #define MODEL_PROPELLANT_POWERLAW_H
      15              : 
      16              : #include "Propellant.H"
      17              : 
      18              : namespace Model
      19              : {
      20              : namespace Propellant
      21              : {
      22              : class PowerLaw
      23              : {
      24              : public:
      25              :     static constexpr const char* name = "powerlaw";
      26              :     
      27            3 :     PowerLaw() = default;
      28              :     PowerLaw(IO::ParmParse &pp, std::string name) 
      29              :     {
      30              :         pp_queryclass(name,*this);
      31              :     }
      32              : 
      33              : 
      34              :     AMREX_FORCE_INLINE AMREX_GPU_HOST_DEVICE
      35              :     void set_pressure(const Set::Scalar P) 
      36              :     {
      37              :         // for the pressure power law option
      38         5656 :         fmod_ap = r_ap * pow(P, n_ap);
      39         5656 :         fmod_htpb = r_htpb * pow(P, n_htpb);
      40         5656 :         fmod_comb = r_comb * pow(P, n_comb);
      41              : 
      42              :         // a_fit = -1.16582 * sin(P) - 0.681788 * cos(P) + 3.3563;
      43              :         // b_fit = -0.708225 * sin(P) + 0.548067 * cos(P) + 1.55985;
      44              :         // c_fit = -0.0130849 * sin(P) - 0.03597 * cos(P) + 0.00725694;
      45         5656 :     }
      46              : 
      47              :     AMREX_FORCE_INLINE AMREX_GPU_HOST_DEVICE
      48     57360384 :     Set::Scalar get_K (const Set::Scalar /*phi*/) {return NAN;}
      49              :     AMREX_FORCE_INLINE AMREX_GPU_HOST_DEVICE
      50     57360384 :     Set::Scalar get_rho (const Set::Scalar /*phi*/) {return NAN;}
      51              :     AMREX_FORCE_INLINE AMREX_GPU_HOST_DEVICE
      52     57360384 :     Set::Scalar get_cp (const Set::Scalar /*phi*/) {return NAN;}
      53              :     AMREX_FORCE_INLINE AMREX_GPU_HOST_DEVICE
      54            0 :     Set::Scalar get_qdot (const Set::Scalar /*mdot*/, const Set::Scalar /*phi*/) {return NAN;}
      55              : 
      56              :     AMREX_FORCE_INLINE AMREX_GPU_HOST_DEVICE
      57              :     Set::Scalar get_L (Set::Scalar phi, Set::Scalar /*T*/) 
      58              :     {
      59     57360384 :         Set::Scalar L = NAN;
      60              :         // if (homogeneousSystem == 1) {
      61              :         //     Set::Vector grad_eta = Numeric::Gradient(eta, i, j, k, 0, DX);
      62              :         //     Set::Scalar angle = acos(grad_eta[0] / grad_eta.lpNorm<2>()) * 180 / 3.1415;
      63              :         //     if (angle > 90) angle = angle - 90.0;
      64              :         //     if (angle > 180) angle = angle - 180.0;
      65              :         //     if (angle > 270) angle = angle - 270.0;
      66              :         //     L = pressure.power.a_fit + pressure.power.b_fit * exp(-pressure.power.c_fit * angle);
      67              :         // }
      68              :         // else 
      69              :         {
      70     57360384 :             Set::Scalar fs_actual = fmod_ap * phi
      71     57360384 :                 + fmod_htpb * (1.0 - phi)
      72     57360384 :                 + 4.0 * fmod_comb * phi * (1.0 - phi);
      73     57360384 :             L = fs_actual / gamma / deltaw /*(pf.w1 - pf.w0)*/;
      74              :         }
      75              : 
      76     57360384 :         return L;
      77              :     }
      78              : 
      79            2 :     static void Parse(PowerLaw& value, IO::ParmParse& pp)
      80              :     {
      81           10 :         Util::Message(INFO,pp.getPrefix());
      82              :         // Scaling factor for mobility
      83           12 :         pp_query_required("gamma", value.gamma);   
      84              :         // AP power pressure law parameter (r*P^n)
      85           12 :         pp_query_required("r_ap", value.r_ap);
      86              :         // HTPB power pressure law parameter (r*P^n)
      87           12 :         pp_query_required("r_htpb", value.r_htpb);
      88              :         // AP/HTPB power pressure law parameter (r*P^n)
      89           12 :         pp_query_required("r_comb", value.r_comb);
      90              :         // AP power pressure law parameter (r*P^n)
      91           12 :         pp_query_required("n_ap", value.n_ap);
      92              :         // HTPB power pressure law parameter (r*P^n)
      93           12 :         pp_query_required("n_htpb", value.n_htpb);
      94              :         // AP/HTPB power pressure law parameter (r*P^n)
      95           12 :         pp_query_required("n_comb", value.n_comb); 
      96              :         // jump in chemical potential
      97           10 :         pp_query_default("deltaw", value.deltaw, 1.0); 
      98            2 :     }
      99              : 
     100              :     Set::Scalar gamma = NAN;
     101              :     Set::Scalar r_ap = NAN, r_htpb = NAN, r_comb = NAN;
     102              :     Set::Scalar n_ap = NAN, n_htpb = NAN, n_comb = NAN;
     103              :     Set::Scalar fmod_ap = NAN, fmod_htpb = NAN, fmod_comb = NAN;
     104              :     Set::Scalar deltaw = NAN;
     105              : };
     106              : }
     107              : }
     108              : 
     109              : #endif