refactor how shape functions are selected in the input file

there used to be a flag quadratic_shape_function_enabled
now the user sets shape_function_type to one of the types available

Author: dicengine

src/api/DICe_api.cpp

@@ -113,7 +113,7 @@ DICE_LIB_DLL_EXPORT const int_t dice_correlate(scalar_t points[], int_t n_points
   // call set_params on the schema in case the parameter have changed:
   if(!initialized||update_params)
     schema.set_params(params);
-  TEUCHOS_TEST_FOR_EXCEPTION(schema.quadratic_shape_function_enabled(),std::runtime_error,"Error, cannot use quadratic shape function for the api routines");
+  TEUCHOS_TEST_FOR_EXCEPTION(schema.shape_function_type()!=DICe::AFFINE_SF,std::runtime_error,"Error, can only use AFFINE shape function for the api routines");
 
 
   initialized = true;
@@ -258,7 +258,7 @@ DICE_LIB_DLL_EXPORT const int_t dice_correlate_conformal(scalar_t points[],
     schema.local_field_value(i,DICe::field_enums::BETA_FS)           = points[i*DICE_API_STRIDE + 7];
     schema.local_field_value(i,DICe::field_enums::STATUS_FLAG_FS)    = points[i*DICE_API_STRIDE + 8];
   }
-  TEUCHOS_TEST_FOR_EXCEPTION(schema.quadratic_shape_function_enabled(),std::runtime_error,"Error, cannot use quadratic shape function for the api routines");
+  TEUCHOS_TEST_FOR_EXCEPTION(schema.shape_function_type()!=DICe::AFFINE_SF,std::runtime_error,"Error, can only use AFFINE shape function for the api routines");
 
   schema.execute_correlation();
 

src/base/DICe.h

@@ -166,7 +166,7 @@ const char* const convert_cine_to_8_bit = "convert_cine_to_8_bit";
 /// String parameter name
 const char* const initial_condition_file = "initial_condition_file";
 /// String parameter name
-const char* const enable_quadratic_shape_function = "enable_quadratic_shape_function";
+const char* const shape_function_type = "shape_function_type";
 /// String parameter name
 const char* const enable_translation = "enable_translation";
 /// String parameter name
@@ -345,7 +345,7 @@ enum Analysis_Type {
   NO_SUCH_ANALYSIS_TYPE
 };
 
-/// Projection method
+/// Global formulation
 enum Global_Formulation {
   HORN_SCHUNCK=0,
   MIXED_HORN_SCHUNCK,
@@ -409,6 +409,22 @@ const static char * initializationMethodStrings[] = {
   "INITIALIZATION_METHOD_NOT_APPLICABLE"
 };
 
+/// Shape function type
+enum Shape_Function_Type {
+  AFFINE_SF=0,
+  QUADRATIC_SF,
+  PROJECTION_SF,
+  // DON'T ADD ANY BELOW MAX
+  MAX_SF,
+  NO_SUCH_SF
+};
+
+const static char * shapeFunctionTypeStrings[] = {
+  "AFFINE",
+  "QUADRATIC",
+  "PROJECTION"
+};
+
 /// Optimization method
 enum Optimization_Method {
   SIMPLEX=0,
@@ -901,10 +917,12 @@ const Correlation_Parameter initial_condition_file_param(initial_condition_file,
   true,
   "Denotes a file to read the solution from as the initial condition");
 /// Correlation parameter and properties
-const Correlation_Parameter enable_quadratic_shape_function_param(enable_quadratic_shape_function,
-  BOOL_PARAM,
+const Correlation_Parameter shape_function_type_param(shape_function_type,
+  STRING_PARAM,
   true,
-  "Enables the quadratic shape function degrees of freedom (all components are activiated and individual components like rotation or shear cannot be disabled)");
+  "Determines what type of shape function is used",
+  shapeFunctionTypeStrings,
+  MAX_SF);
 /// Correlation parameter and properties
 const Correlation_Parameter enable_translation_param(enable_translation,
   BOOL_PARAM,
@@ -1145,7 +1163,7 @@ const Correlation_Parameter valid_correlation_params[num_valid_correlation_param
   compute_image_gradients_param,
   gauss_filter_images_param,
   initial_condition_file_param,
-  enable_quadratic_shape_function_param,
+  shape_function_type_param,
   enable_translation_param,
   enable_rotation_param,
   enable_normal_strain_param,

src/base/DICe_LocalShapeFunction.cpp

@@ -50,11 +50,12 @@ DICE_LIB_DLL_EXPORT
 Teuchos::RCP<Local_Shape_Function> shape_function_factory(Schema * schema){
   if(!schema){
     return Teuchos::rcp(new Affine_Shape_Function(schema));
-  }
-  else if(schema->quadratic_shape_function_enabled()){
+  }else if(schema->shape_function_type()==DICe::AFFINE_SF){
+    return Teuchos::rcp(new Affine_Shape_Function(schema));
+  }else if(schema->shape_function_type()==DICe::QUADRATIC_SF){
     return Teuchos::rcp(new Quadratic_Shape_Function());
   }else{
-    return Teuchos::rcp(new Affine_Shape_Function(schema));
+    TEUCHOS_TEST_FOR_EXCEPTION(true,std::runtime_error,"Error, invalid shape function type");
   }
 }
 

src/core/DICe_Initializer.cpp

@@ -386,8 +386,8 @@ Field_Value_Initializer::initial_guess(const int_t subset_gid,
       return INITIALIZE_USING_PREVIOUS_FRAME_SUCCESSFUL;
     else{
       // if using a neighbor's value, the parameters have to be adjusted to account
-      // for the change in centroids
-      if(schema_->quadratic_shape_function_enabled()){
+      // for the change in centroids for the quadratic shape function
+      if(schema_->shape_function_type()==DICe::QUADRATIC_SF){
         scalar_t cx = schema_->global_field_value(subset_gid,SUBSET_COORDINATES_X_FS);
         scalar_t cy = schema_->global_field_value(subset_gid,SUBSET_COORDINATES_Y_FS);
         scalar_t cx_neigh = schema_->global_field_value(sid,SUBSET_COORDINATES_X_FS);

src/core/DICe_ParameterUtilities.cpp

@@ -123,6 +123,11 @@ const std::string to_string(Optimization_Method in){
   return optimizationMethodStrings[in];
 }
 DICE_LIB_DLL_EXPORT
+const std::string to_string(Shape_Function_Type in){
+  assert(in < MAX_SF);
+  return shapeFunctionTypeStrings[in];
+}
+DICE_LIB_DLL_EXPORT
 const std::string to_string(Interpolation_Method in){
   assert(in < MAX_INTERPOLATION_METHOD);
   return interpolationMethodStrings[in];
@@ -294,7 +299,7 @@ DICE_LIB_DLL_EXPORT void tracking_default_params(Teuchos::ParameterList *  defau
   defaultParams->set(DICe::projection_method,DICe::DISPLACEMENT_BASED);
   defaultParams->set(DICe::disp_jump_tol,8.0);
   defaultParams->set(DICe::theta_jump_tol,0.1);
-  defaultParams->set(DICe::enable_quadratic_shape_function,false);
+  defaultParams->set(DICe::shape_function_type,DICe::AFFINE_SF);
   defaultParams->set(DICe::enable_translation,true);
   defaultParams->set(DICe::enable_rotation,true);
   defaultParams->set(DICe::enable_normal_strain,false);
@@ -355,7 +360,7 @@ DICE_LIB_DLL_EXPORT void dice_default_params(Teuchos::ParameterList *  defaultPa
   defaultParams->set(DICe::use_search_initialization_for_failed_steps,false);
   defaultParams->set(DICe::disp_jump_tol,10000.0);
   defaultParams->set(DICe::theta_jump_tol,100.0);
-  defaultParams->set(DICe::enable_quadratic_shape_function,false);
+  defaultParams->set(DICe::shape_function_type,DICe::AFFINE_SF);
   defaultParams->set(DICe::enable_translation,true);
   defaultParams->set(DICe::enable_rotation,false);
   defaultParams->set(DICe::enable_normal_strain,false);

src/core/DICe_ParameterUtilities.h

@@ -83,6 +83,10 @@ const std::string to_string(Initialization_Method in);
 DICE_LIB_DLL_EXPORT
 const std::string to_string(Optimization_Method in);
 
+/// Convert a DICe::Shape_Function_Type to string
+DICE_LIB_DLL_EXPORT
+const std::string to_string(Shape_Function_Type in);
+
 /// Convert a DICe::Interpolation_Method to string
 DICE_LIB_DLL_EXPORT
 const std::string to_string(Interpolation_Method in);

src/core/DICe_Schema.cpp

@@ -552,8 +552,8 @@ Schema::set_params(const Teuchos::RCP<Teuchos::ParameterList> & params){
   enable_normal_strain_ = diceParams->get<bool>(DICe::enable_normal_strain);
   TEUCHOS_TEST_FOR_EXCEPTION(!diceParams->isParameter(DICe::enable_shear_strain),std::runtime_error,"");
   enable_shear_strain_ = diceParams->get<bool>(DICe::enable_shear_strain);
-  TEUCHOS_TEST_FOR_EXCEPTION(!diceParams->isParameter(DICe::enable_quadratic_shape_function),std::runtime_error,"");
-  enable_quadratic_shape_function_ = diceParams->get<bool>(DICe::enable_quadratic_shape_function);
+  TEUCHOS_TEST_FOR_EXCEPTION(!diceParams->isParameter(DICe::shape_function_type),std::runtime_error,"");
+  shape_function_type_ = diceParams->get<Shape_Function_Type>(DICe::shape_function_type);
   TEUCHOS_TEST_FOR_EXCEPTION(!diceParams->isParameter(DICe::output_deformed_subset_images),std::runtime_error,"");
   output_deformed_subset_images_ = diceParams->get<bool>(DICe::output_deformed_subset_images);
   TEUCHOS_TEST_FOR_EXCEPTION(!diceParams->isParameter(DICe::output_deformed_subset_intensity_images),std::runtime_error,"");
@@ -935,14 +935,14 @@ Schema::initialize(const Teuchos::RCP<Teuchos::ParameterList> & input_params,
         if(proc_rank==0) DEBUG_MSG("Seeding the displacement solution for subset " << subset_id << " with ux: " <<
           global_field_value(subset_id,SUBSET_DISPLACEMENT_X_FS) << " uy: " << global_field_value(subset_id,SUBSET_DISPLACEMENT_Y_FS));
         if(subset_info->normal_strain_map->find(roi_id)!=subset_info->normal_strain_map->end()){
-          TEUCHOS_TEST_FOR_EXCEPTION(enable_quadratic_shape_function_,std::runtime_error,"Error, seeds can't be used with the quadratic shape function enabled");
+          TEUCHOS_TEST_FOR_EXCEPTION(shape_function_type_!=DICe::AFFINE_SF,std::runtime_error,"Error, seeds can only be used with the affine shape function");
           global_field_value(subset_id,NORMAL_STRETCH_XX_FS) = subset_info->normal_strain_map->find(roi_id)->second.first;
           global_field_value(subset_id,NORMAL_STRETCH_YY_FS) = subset_info->normal_strain_map->find(roi_id)->second.second;
           if(proc_rank==0) DEBUG_MSG("Seeding the normal strain solution for subset " << subset_id << " with ex: " <<
             global_field_value(subset_id,NORMAL_STRETCH_XX_FS) << " ey: " << global_field_value(subset_id,NORMAL_STRETCH_YY_FS));
         }
         if(subset_info->shear_strain_map->find(roi_id)!=subset_info->shear_strain_map->end()){
-          TEUCHOS_TEST_FOR_EXCEPTION(enable_quadratic_shape_function_,std::runtime_error,"Error, seeds can't be used with the quadratic shape function enabled");
+          TEUCHOS_TEST_FOR_EXCEPTION(shape_function_type_!=DICe::AFFINE_SF,std::runtime_error,"Error, seeds can only be used with the affine shape function");
           global_field_value(subset_id,SHEAR_STRETCH_XY_FS) = subset_info->shear_strain_map->find(roi_id)->second;
           if(proc_rank==0) DEBUG_MSG("Seeding the shear strain solution for subset " << subset_id << " with gamma_xy: " <<
             global_field_value(subset_id,SHEAR_STRETCH_XY_FS));
@@ -3281,7 +3281,7 @@ Output_Spec::Output_Spec(Schema * schema,
     field_names_.push_back(SUBSET_DISPLACEMENT_X_FS.get_name_label());
     field_names_.push_back(SUBSET_DISPLACEMENT_Y_FS.get_name_label());
     field_names_.push_back(ROTATION_Z_FS.get_name_label());
-    if(!schema->quadratic_shape_function_enabled()){
+    if(schema->shape_function_type()==DICe::AFFINE_SF){
       field_names_.push_back(NORMAL_STRETCH_XX_FS.get_name_label());
       field_names_.push_back(NORMAL_STRETCH_YY_FS.get_name_label());
       field_names_.push_back(SHEAR_STRETCH_XY_FS.get_name_label());
@@ -3411,7 +3411,7 @@ Output_Spec::write_info(std::FILE * file,
   fprintf(file,"*** Guess initialization method: %s\n",init_method.c_str());
   fprintf(file,"*** Seed location: N/A\n");
   fprintf(file,"*** Shape functions: ");
-  if(schema_->quadratic_shape_function_enabled()){
+  if(schema_->shape_function_type()==DICe::QUADRATIC_SF){
     fprintf(file,"quadratic (A,B,C,D,E,F,G,H,I,J,K,L)");
   }else{
     if(schema_->translation_enabled())

src/core/DICe_Schema.h

@@ -741,8 +741,8 @@ Schema {
 
   // shape function controls:
   /// Returns true if all quadratic shape functions are enabled
-  bool quadratic_shape_function_enabled() const {
-    return enable_quadratic_shape_function_;
+  Shape_Function_Type shape_function_type() const {
+    return shape_function_type_;
   }
 
   /// Returns true if translation shape functions are enabled
@@ -802,8 +802,8 @@ Schema {
   }
 
   /// Enable translation shape functions
-  void enable_quadratic_shape_function(const bool flag){
-    enable_quadratic_shape_function_ = flag;
+  void set_shape_function_type(const Shape_Function_Type sft){
+    shape_function_type_ = sft;
   }
 
   /// Enable translation shape functions
@@ -1159,8 +1159,8 @@ Schema {
   Projection_Method projection_method_;
   /// Analysis type
   Analysis_Type analysis_type_;
-  /// Enable the quadratic shape functions all together rather than individual components
-  bool enable_quadratic_shape_function_;
+  /// Shape function type
+  Shape_Function_Type shape_function_type_;
   /// Enable translation
   bool enable_translation_;
   /// Enable rotation