Replaced string option for interpolation in diffusion with class enum

jeanlucf22 · jeanlucf22 · commit 5e8fcbba0910 · 2018-06-12T13:54:16.000-04:00
diff --git a/source/CompositionDiffusionStrategy.h b/source/CompositionDiffusionStrategy.h
@@ -7,9 +7,20 @@
 
 using namespace SAMRAI;
 
+enum class DiffusionInterpolationType
+{
+   LINEAR,
+   PBG,
+   UNDEFINED
+};
+
 class CompositionDiffusionStrategy
 {
 public:
+   CompositionDiffusionStrategy(DiffusionInterpolationType interp_func_type)
+      : d_interp_func_type(interp_func_type)
+   {};
+
 /*
  * compute actual diffusion by weighting diffusion in each phase
  * using phase variable
@@ -20,6 +31,15 @@ class CompositionDiffusionStrategy
       const int phase_id,
       const int eta_id)=0;
 
+protected:
+   char interpChar()const
+   {
+      return ((d_interp_func_type
+       ==DiffusionInterpolationType::LINEAR) ? 'l' : 'p');
+   }
+
+private:
+   DiffusionInterpolationType d_interp_func_type;
 };
 
 #endif
diff --git a/source/DiffusionForConcInPhaseStrategy.C b/source/DiffusionForConcInPhaseStrategy.C
@@ -61,9 +61,10 @@ DiffusionForConcInPhaseStrategy::DiffusionForConcInPhaseStrategy(
    const int diffusion_coeff_a_id,
    const int diffusion_coeff_b_id,
    const std::string& avg_func_type,
-   const std::string& diff_interp_func_type,
+   DiffusionInterpolationType diff_interp_type,
    CompositionStrategyMobilities* mobilities_strategy,
    FreeEnergyStrategy* free_energy_strategy):
+      CompositionDiffusionStrategy(diff_interp_type),
       d_mobilities_strategy(mobilities_strategy),
       d_free_energy_strategy(free_energy_strategy)
 {
@@ -82,7 +83,6 @@ DiffusionForConcInPhaseStrategy::DiffusionForConcInPhaseStrategy(
    d_diffusion_coeff_b_id=diffusion_coeff_b_id;
 
    d_avg_func_type=avg_func_type;
-   d_diff_interp_func_type=diff_interp_func_type;
 
    d_with_third_phase = ( conc_b_scratch_id>=0 );
 
@@ -464,10 +464,8 @@ void DiffusionForConcInPhaseStrategy::setDiffCoeffInEachPhaseOnPatch(
             
             if( d_with_third_phase && d_same_composition_for_third_phase )
             {
-               double heta =
-                  FORT_INTERP_FUNC( eta, d_diff_interp_func_type.c_str() );
                for(unsigned short ic=0;ic<d_ncompositions;ic++){
-                  c_s[ic] = (1.-heta)*c_a[ic]+heta*c_b[ic];
+                  c_s[ic] = (1.-eta)*c_a[ic]+eta*c_b[ic];
                }
                computeLocalDiffusionMatrixA(temp, c_s);
                for(int ic=0;ic<nc2;ic++){
@@ -536,10 +534,8 @@ void DiffusionForConcInPhaseStrategy::setDiffCoeffInEachPhaseOnPatch(
             
             if( d_with_third_phase && d_same_composition_for_third_phase )
             {
-               double heta =
-                  FORT_INTERP_FUNC( eta, d_diff_interp_func_type.c_str() );
                for(unsigned short ic=0;ic<d_ncompositions;ic++){
-                  c_s[ic] = (1.-heta)*c_a[ic]+heta*c_b[ic];
+                  c_s[ic] = (1.-eta)*c_a[ic]+eta*c_b[ic];
                }
                
                computeLocalDiffusionMatrixA(temp, c_s);
@@ -611,10 +607,8 @@ void DiffusionForConcInPhaseStrategy::setDiffCoeffInEachPhaseOnPatch(
             
                if( d_with_third_phase && d_same_composition_for_third_phase )
                {
-                  double heta =
-                     FORT_INTERP_FUNC( eta, d_diff_interp_func_type.c_str() );
                   for(unsigned short ic=0;ic<d_ncompositions;ic++){
-                     c_s[ic] = (1.-heta)*c_a[ic]+heta*c_b[ic];
+                     c_s[ic] = (1.-eta)*c_a[ic]+eta*c_b[ic];
                   }
                
                   computeLocalDiffusionMatrixA(temp, c_s);
@@ -782,6 +776,8 @@ void DiffusionForConcInPhaseStrategy::setDiffOnPatch(
    kmin = pbox.lower(2);
    kmax = pbox.upper(2);
 #endif
+
+   const char interp_func = interpChar();
          
    // X-side
    for ( int kk = kmin; kk <= kmax; kk++ ) {
@@ -800,7 +796,7 @@ void DiffusionForConcInPhaseStrategy::setDiffOnPatch(
             double hphi =
                FORT_INTERP_FUNC(
                   phi,
-                  d_diff_interp_func_type.c_str() );
+                  &interp_func );
             
             double heta = 0.0;
             if ( d_with_third_phase ) {
@@ -809,7 +805,7 @@ void DiffusionForConcInPhaseStrategy::setDiffOnPatch(
                heta =
                   FORT_INTERP_FUNC(
                      eta,
-                     d_diff_interp_func_type.c_str() );
+                     &interp_func );
             }
 
             for(unsigned int ic=0;ic<nc2;ic++){
@@ -844,7 +840,7 @@ void DiffusionForConcInPhaseStrategy::setDiffOnPatch(
             double hphi =
                FORT_INTERP_FUNC(
                   phi,
-                  d_diff_interp_func_type.c_str() );
+                  &interp_func );
             
             double heta = 0.0;
             if ( d_with_third_phase ) {
@@ -853,7 +849,7 @@ void DiffusionForConcInPhaseStrategy::setDiffOnPatch(
                heta =
                   FORT_INTERP_FUNC(
                      eta,
-                     d_diff_interp_func_type.c_str() );
+                     &interp_func );
             }
 
             for(unsigned int ic=0;ic<nc2;ic++){
@@ -889,7 +885,7 @@ void DiffusionForConcInPhaseStrategy::setDiffOnPatch(
                double hphi =
                   FORT_INTERP_FUNC(
                      phi,
-                     d_diff_interp_func_type.c_str() );
+                     &interp_func );
 
                double heta = 0.0;
                if ( d_with_third_phase ) {
@@ -898,7 +894,7 @@ void DiffusionForConcInPhaseStrategy::setDiffOnPatch(
                   heta =
                      FORT_INTERP_FUNC(
                         eta,
-                        d_diff_interp_func_type.c_str() );
+                        &interp_func );
                }
 
                for(unsigned int ic=0;ic<nc2;ic++){
diff --git a/source/DiffusionForConcInPhaseStrategy.h b/source/DiffusionForConcInPhaseStrategy.h
@@ -63,7 +63,7 @@ class DiffusionForConcInPhaseStrategy
       const int diffusion_coeff_a_id,
       const int diffusion_coeff_b_id,
       const std::string& avg_func_type,
-      const std::string& diff_interp_func_type,
+      DiffusionInterpolationType diff_interp_type,
       CompositionStrategyMobilities* mobilities_strategy,
       FreeEnergyStrategy* free_energy_strategy);
 
@@ -154,8 +154,6 @@ class DiffusionForConcInPhaseStrategy
 
    bool d_with_third_phase;
    
-   std::string d_diff_interp_func_type;
-
    CompositionStrategyMobilities* d_mobilities_strategy;
    
    // free energy needed to compute diffusion in each phase
diff --git a/source/QuatModel.C b/source/QuatModel.C
@@ -346,7 +346,7 @@ void QuatModel::initializeCompositionRHSStrategy(
             d_model_parameters.Q0_liquid(),
             d_model_parameters.Q0_solid_A(),
             d_model_parameters.Q0_solid_B(),
-            d_model_parameters.diffusion_interp_func_type(),
+            d_model_parameters.energy_interp_func_type(),
             d_model_parameters.avg_func_type() );
    }else if ( d_model_parameters.concRHSstrategyIsEBS() ){
       
@@ -382,7 +382,7 @@ void QuatModel::initializeCompositionRHSStrategy(
             d_conc_phase_coupling_diffusion_id,
             d_model_parameters.D_liquid(),
             d_model_parameters.D_solid_A(),
-            d_model_parameters.diffusion_interp_func_type(),
+            d_model_parameters.conc_interp_func_type(),
             d_model_parameters.avg_func_type() );
    }else{
       TBOX_ERROR( "Error: unknown composition RHS Strategy" );
diff --git a/source/QuatModelParameters.C b/source/QuatModelParameters.C
@@ -101,7 +101,8 @@ QuatModelParameters::QuatModelParameters()
    d_orient_interp_func_type = "";
    d_conc_interp_func_type = "";
    d_energy_interp_func_type = "";
-   d_diffusion_interp_func_type = "";
+   d_diffusion_interp_type =
+      DiffusionInterpolationType::UNDEFINED;
    d_eta_well_func_type = "";
    d_eta_interp_func_type = "";
    d_eta_well_func_type = "";
@@ -829,9 +830,25 @@ void QuatModelParameters::readModelParameters(boost::shared_ptr<tbox::Database>
    d_conc_interp_func_type =
       model_db->getStringWithDefault( "conc_interp_func_type",
                                       d_energy_interp_func_type );
-   d_diffusion_interp_func_type =
+   string diffusion_interp_type = 
       model_db->getStringWithDefault( "diffusion_interp_func_type",
-                                      d_energy_interp_func_type );
+                                      "linear" );
+   switch( diffusion_interp_type[0] ){
+      case 'l':
+      case 'L':
+         d_diffusion_interp_type =
+            DiffusionInterpolationType::LINEAR;
+         break;
+      case 'p':
+      case 'P':
+         d_diffusion_interp_type =
+            DiffusionInterpolationType::PBG;
+         break;
+      default:
+         tbox::plog<<"diffusion_interp_type="
+                   <<diffusion_interp_type<<endl;
+         TBOX_ERROR( "Error: invalid diffusion_interp_type!!!");
+   }
 
    // Currently "arithmetic" or "harmonic"
    // arithmetic: (x1+x2)/2
diff --git a/source/QuatModelParameters.h b/source/QuatModelParameters.h
@@ -34,6 +34,7 @@
 #define included_QuatModelParameters
 
 #include "tools.h"
+#include "CompositionDiffusionStrategy.h"
 
 // Headers for basic SAMRAI objects
 #include "SAMRAI/tbox/MemoryDatabase.h"
@@ -173,8 +174,9 @@ class QuatModelParameters
       return d_energy_interp_func_type;
    }
    std::string eta_interp_func_type()const{ return d_eta_interp_func_type; }
-   std::string diffusion_interp_func_type()const{
-      return d_diffusion_interp_func_type;
+   DiffusionInterpolationType
+      diffusion_interp_func_type()const{
+         return d_diffusion_interp_type;
    }
    
    std::string avg_func_type()const{ return d_avg_func_type; }
@@ -401,10 +403,23 @@ class QuatModelParameters
     *    "3" for cubic, phi^3
     */
    std::string d_orient_interp_func_type;
+
+   /*!
+    * form of h_r(phi)
+    */
    std::string d_conc_interp_func_type;
+
+   /*!
+    * form of h_p(phi)
+    */
    std::string d_energy_interp_func_type;
+
    std::string d_eta_interp_func_type;
-   std::string d_diffusion_interp_func_type;
+
+   /*!
+    * form of h_d(phi)
+    */
+   DiffusionInterpolationType d_diffusion_interp_type;
    
    std::string d_avg_func_type;
    std::string d_diffq_avg_func_type;
diff --git a/source/TbasedCompositionDiffusionStrategy.C b/source/TbasedCompositionDiffusionStrategy.C
@@ -12,15 +12,15 @@ TbasedCompositionDiffusionStrategy::TbasedCompositionDiffusionStrategy(
    const int diffusion_a_id,
    const double D_liquid, const double Q0_liquid,
    const double D_solid_A, const double Q0_solid_A,
-   const string& phase_interp_func_type,
+   const DiffusionInterpolationType interp_func_type,
    const string& avg_func_type):
+      CompositionDiffusionStrategy(interp_func_type),
       d_diffusion_l_id(diffusion_l_id),
       d_diffusion_a_id(diffusion_a_id),
       d_D_liquid(D_liquid),
       d_Q0_liquid(Q0_liquid),
       d_D_solid_A(D_solid_A),
       d_Q0_solid_A(Q0_solid_A),
-      d_phase_interp_func_type(phase_interp_func_type),
       d_avg_func_type(avg_func_type)
 {
    assert( D_liquid >= 0. );
@@ -45,6 +45,8 @@ void TbasedCompositionDiffusionStrategy::setDiffusion(
 
    const int maxl = hierarchy->getNumberOfLevels();
 
+   const char interp_func_type = interpChar();
+
    for ( int amr_level = 0; amr_level < maxl; amr_level++ ) {
       boost::shared_ptr<hier::PatchLevel > level =
          hierarchy->getPatchLevel( amr_level );
@@ -102,7 +104,7 @@ void TbasedCompositionDiffusionStrategy::setDiffusion(
             d_D_liquid, d_Q0_liquid,
             d_D_solid_A, d_Q0_solid_A,
             gas_constant_R_JpKpmol,
-            d_phase_interp_func_type.c_str(),
+            &interp_func_type,
             d_avg_func_type.c_str());
 
          //fill other diagonal value with same value for ternaries for now
diff --git a/source/TbasedCompositionDiffusionStrategy.h b/source/TbasedCompositionDiffusionStrategy.h
@@ -17,7 +17,7 @@ class TbasedCompositionDiffusionStrategy :
       const int diffusion_a_id,
       const double D_liquid, const double Q0_liquid,
       const double D_solid_A, const double Q0_solid_A,
-      const string& phase_interp_func_type,
+      DiffusionInterpolationType interp_func_type,
       const string& avg_func_type
 );
 
@@ -46,7 +46,6 @@ class TbasedCompositionDiffusionStrategy :
    double d_D_solid_A;
    double d_Q0_solid_A;
 
-   std::string d_phase_interp_func_type;
    std::string d_avg_func_type;
 };
 
