Merge pull request #1845 from CEED/jeremy/get-name

OP Get Name Helper

Author: jeremylt

include/ceed/backend.h

@@ -366,6 +366,7 @@ CEED_EXTERN int CeedQFunctionSetFortranStatus(CeedQFunction qf, bool status);
 CEED_EXTERN int CeedQFunctionGetVectorLength(CeedQFunction qf, CeedInt *vec_length);
 CEED_EXTERN int CeedQFunctionGetNumArgs(CeedQFunction qf, CeedInt *num_input_fields, CeedInt *num_output_fields);
 CEED_EXTERN int CeedQFunctionGetKernelName(CeedQFunction qf, const char **kernel_name);
+CEED_EXTERN int CeedQFunctionGetName(CeedQFunction qf, const char **name);
 CEED_EXTERN int CeedQFunctionGetSourcePath(CeedQFunction qf, const char **source_path);
 CEED_EXTERN int CeedQFunctionLoadSourceToBuffer(CeedQFunction qf, const char **source_buffer);
 CEED_EXTERN int CeedQFunctionGetUserFunction(CeedQFunction qf, CeedQFunctionUser *f);

include/ceed/ceed.h

@@ -448,6 +448,7 @@ CEED_EXTERN int  CeedOperatorMultigridLevelCreateH1(CeedOperator op_fine, CeedVe
                                                     CeedOperator *op_prolong, CeedOperator *op_restrict);
 CEED_EXTERN int  CeedOperatorCreateFDMElementInverse(CeedOperator op, CeedOperator *fdm_inv, CeedRequest *request);
 CEED_EXTERN int  CeedOperatorSetName(CeedOperator op, const char *name);
+CEED_EXTERN int  CeedOperatorGetName(CeedOperator op, const char **name);
 CEED_EXTERN int  CeedOperatorView(CeedOperator op, FILE *stream);
 CEED_EXTERN int  CeedOperatorViewTerse(CeedOperator op, FILE *stream);
 CEED_EXTERN int  CeedOperatorGetCeed(CeedOperator op, Ceed *ceed);

interface/ceed-operator.c

@@ -1553,6 +1553,29 @@ int CeedOperatorSetName(CeedOperator op, const char *name) {
   return CEED_ERROR_SUCCESS;
 }
 
+/**
+  @brief Get name of `CeedOperator`
+
+  @param[in]     op   `CeedOperator`
+  @param[in,out] name Address of variable to hold currently set name
+
+  @return An error code: 0 - success, otherwise - failure
+
+  @ref User
+**/
+int CeedOperatorGetName(CeedOperator op, const char **name) {
+  if (op->name) {
+    *name = op->name;
+  } else if (!op->is_composite) {
+    CeedQFunction qf;
+
+    CeedCall(CeedOperatorGetQFunction(op, &qf));
+    if (qf) CeedCall(CeedQFunctionGetName(qf, name));
+    CeedCall(CeedQFunctionDestroy(&qf));
+  }
+  return CEED_ERROR_SUCCESS;
+}
+
 /**
   @brief Core logic for viewing a `CeedOperator`
 
@@ -1565,8 +1588,11 @@ int CeedOperatorSetName(CeedOperator op, const char *name) {
   @ref Developer
 **/
 static int CeedOperatorView_Core(CeedOperator op, FILE *stream, bool is_full) {
-  bool has_name = op->name, is_composite, is_at_points;
+  bool        has_name, is_composite, is_at_points;
+  const char *name = NULL;
 
+  CeedCall(CeedOperatorGetName(op, &name));
+  has_name = name ? strlen(name) : false;
   CeedCall(CeedOperatorIsComposite(op, &is_composite));
   CeedCall(CeedOperatorIsAtPoints(op, &is_at_points));
   if (is_composite) {
@@ -1575,7 +1601,7 @@ static int CeedOperatorView_Core(CeedOperator op, FILE *stream, bool is_full) {
 
     CeedCall(CeedCompositeOperatorGetNumSub(op, &num_suboperators));
     CeedCall(CeedCompositeOperatorGetSubList(op, &sub_operators));
-    fprintf(stream, "Composite CeedOperator%s%s\n", has_name ? " - " : "", has_name ? op->name : "");
+    fprintf(stream, "Composite CeedOperator%s%s\n", has_name ? " - " : "", has_name ? name : "");
 
     for (CeedInt i = 0; i < num_suboperators; i++) {
       has_name = sub_operators[i]->name;
@@ -1584,7 +1610,7 @@ static int CeedOperatorView_Core(CeedOperator op, FILE *stream, bool is_full) {
       if (is_full) CeedCall(CeedOperatorSingleView(sub_operators[i], 1, stream));
     }
   } else {
-    fprintf(stream, "CeedOperator%s%s%s\n", is_at_points ? " AtPoints" : "", has_name ? " - " : "", has_name ? op->name : "");
+    fprintf(stream, "CeedOperator%s%s%s\n", is_at_points ? " AtPoints" : "", has_name ? " - " : "", has_name ? name : "");
     if (is_full) CeedCall(CeedOperatorSingleView(op, 0, stream));
   }
   return CEED_ERROR_SUCCESS;

interface/ceed-preconditioning.c

@@ -1838,14 +1838,16 @@ int CeedOperatorGetFallback(CeedOperator op, CeedOperator *op_fallback) {
     CeedCall(CeedIsDebug(ceed, &is_debug));
     if (is_debug) {
       Ceed        ceed_fallback;
-      const char *resource, *resource_fallback;
+      const char *resource, *resource_fallback, *op_name;
 
       CeedCall(CeedGetOperatorFallbackCeed(ceed, &ceed_fallback));
       CeedCall(CeedGetResource(ceed, &resource));
       CeedCall(CeedGetResource(ceed_fallback, &resource_fallback));
+      CeedCall(CeedOperatorGetName(op, &op_name));
 
       CeedDebug256(ceed, CEED_DEBUG_COLOR_SUCCESS, "---------- CeedOperator Fallback ----------\n");
-      CeedDebug(ceed, "Falling back from %s operator at address %p to %s operator at address %p\n", resource, op, resource_fallback, op->op_fallback);
+      CeedDebug(ceed, "CeedOperator \"%s\": falling back from operator at address %p with backend %s to operator at address %p with backend %s\n",
+                op_name, resource, op, resource_fallback, op->op_fallback);
       CeedCall(CeedDestroy(&ceed_fallback));
     }
     CeedCall(CeedDestroy(&ceed));

interface/ceed-qfunction.c

@@ -196,11 +196,31 @@ int CeedQFunctionGetNumArgs(CeedQFunction qf, CeedInt *num_input, CeedInt *num_o
   return CEED_ERROR_SUCCESS;
 }
 
+/**
+  @brief Get the name of the `CeedQFunction`.
+    Use the `name` if created via @ref `CeedQFunctionCreateInteriorByName`, otherwise return the kernel name via @ref `CeedQFunctionGetKernelName`.
+
+  @param[in]  qf          `CeedQFunction`
+  @param[out] kernel_name Variable to store `CeedQFunction` name
+
+  @return An error code: 0 - success, otherwise - failure
+
+  @ref Backend
+**/
+int CeedQFunctionGetName(CeedQFunction qf, const char **name) {
+  if (qf->is_gallery) {
+    *name = qf->gallery_name;
+  } else {
+    CeedCall(CeedQFunctionGetKernelName(qf, name));
+  }
+  return CEED_ERROR_SUCCESS;
+}
+
 /**
   @brief Get the name of the user function for a `CeedQFunction`
 
   @param[in]  qf          `CeedQFunction`
-  @param[out] kernel_name Variable to store source path string
+  @param[out] kernel_name Variable to store string holding kernel name
 
   @return An error code: 0 - success, otherwise - failure
 
@@ -1001,10 +1021,10 @@ int CeedQFunctionSetUserFlopsEstimate(CeedQFunction qf, CeedSize flops) {
   @ref User
 **/
 int CeedQFunctionView(CeedQFunction qf, FILE *stream) {
-  const char *kernel_name;
+  const char *name;
 
-  CeedCall(CeedQFunctionGetKernelName(qf, &kernel_name));
-  fprintf(stream, "%sCeedQFunction - %s\n", qf->is_gallery ? "Gallery " : "User ", qf->is_gallery ? qf->gallery_name : kernel_name);
+  CeedCall(CeedQFunctionGetName(qf, &name));
+  fprintf(stream, "%sCeedQFunction - %s\n", qf->is_gallery ? "Gallery " : "User ", name);
 
   fprintf(stream, "  %" CeedInt_FMT " input field%s:\n", qf->num_input_fields, qf->num_input_fields > 1 ? "s" : "");
   for (CeedInt i = 0; i < qf->num_input_fields; i++) {

python/tests/output/test_504.out

@@ -1,4 +1,4 @@
-CeedOperator
+CeedOperator - setup_mass
   15 elements with 8 quadrature points each
   3 fields
   2 input fields:
@@ -20,7 +20,7 @@ CeedOperator
       No basis
       Active vector
 
-CeedOperator
+CeedOperator - apply_mass
   15 elements with 8 quadrature points each
   3 fields
   2 input fields: