Implement ArrayLog(), DistGridLog(), and enable deepFlag passing.

src/Infrastructure/Array/include/ESMCI_Array.h

@@ -439,6 +439,8 @@ namespace ESMCI {
          const std::string &convention, const std::string &purpose,
          bool *overwrite, ESMC_FileStatus_Flag *status,
          int *timeslice, ESMC_IOFmt_Flag *iofmt);
+    void log(std::string prefix,
+      ESMC_LogMsgType_Flag msgType=ESMC_LOGMSG_INFO, bool deepFlag=false)const;
     int print() const;
     int sync();
     int validate() const;

src/Infrastructure/Array/interface/ESMCI_Array_F.C

@@ -839,6 +839,36 @@ extern "C" {
                                   ESMC_NOT_PRESENT_FILTER(rc));
   }
 
+  void FTN_X(c_esmc_arraylog)(ESMCI::Array **array,
+    char *prefix, ESMC_LogMsgType_Flag *logMsgFlag, ESMC_Logical *deep, int *rc,
+    ESMCI_FortranStrLenArg prefix_l){
+#undef  ESMC_METHOD
+#define ESMC_METHOD "c_esmc_arraylog()"
+    if (rc!=NULL) *rc = ESMC_RC_NOT_IMPL;
+    // convert to bool
+    bool deepFlag = false;  // default
+    if (ESMC_NOT_PRESENT_FILTER(deep) != ESMC_NULL_POINTER)
+      if (*deep == ESMF_TRUE) deepFlag = true;
+    try{
+      std::string prefixStr(prefix, prefix_l);
+      (*array)->log(prefixStr, *logMsgFlag, deepFlag);
+    }catch(int localrc){
+      if (ESMC_LogDefault.MsgFoundError(localrc, ESMCI_ERR_PASSTHRU,
+        ESMC_CONTEXT, rc))
+        return; // bail out
+    }catch(std::exception &x){
+      ESMC_LogDefault.MsgFoundError(ESMC_RC_INTNRL_BAD, x.what(), ESMC_CONTEXT,
+        rc);
+      return; // bail out
+    }catch(...){
+      ESMC_LogDefault.MsgFoundError(ESMC_RC_INTNRL_BAD, "- Caught exception", 
+        ESMC_CONTEXT, rc);
+      return;
+    }
+    // return successfully
+    if (rc!=NULL) *rc = ESMF_SUCCESS;
+  }
+
   void FTN_X(c_esmc_arrayprint)(ESMCI::Array **ptr, int *rc){
 #undef  ESMC_METHOD
 #define ESMC_METHOD "c_esmc_arrayprint()"

src/Infrastructure/Array/interface/ESMF_Array.F90

@@ -85,6 +85,7 @@ module ESMF_ArrayMod
   public ESMF_ArrayHaloRelease      ! implemented in ESMF_ArrayHaMod
   public ESMF_ArrayHaloStore        ! implemented in ESMF_ArrayHaMod
   public ESMF_ArrayIsCreated        ! implemented in ESMF_ArrayHaMod
+  public ESMF_ArrayLog              ! implemented in ESMF_ArrayHaMod
   public ESMF_ArrayPrint            ! implemented in ESMF_ArrayHaMod
   public ESMF_ArrayRead             ! implemented in ESMF_ArrayHaMod
   public ESMF_ArrayRedist           ! implemented in ESMF_ArrayHaMod

src/Infrastructure/Array/interface/ESMF_ArrayHa.F90

@@ -68,6 +68,7 @@ module ESMF_ArrayHaMod
   public ESMF_ArrayHaloRelease
   public ESMF_ArrayHaloStore
   public ESMF_ArrayIsCreated
+  public ESMF_ArrayLog
   public ESMF_ArrayPrint
   public ESMF_ArrayRead
   public ESMF_ArrayRedist
@@ -557,6 +558,76 @@ function ESMF_ArrayIsCreated(array, keywordEnforcer, rc)
 !------------------------------------------------------------------------------
 
 
+! -------------------------- ESMF-public method -----------------------------
+#undef  ESMF_METHOD
+#define ESMF_METHOD "ESMF_ArrayLog()"
+!BOP
+! !IROUTINE: ESMF_ArrayLog - Log Array information
+
+! !INTERFACE:
+  subroutine ESMF_ArrayLog(array, keywordEnforcer, prefix, logMsgFlag, deepFlag, rc)
+!
+! !ARGUMENTS:
+    type(ESMF_Array),       intent(in)              :: array
+type(ESMF_KeywordEnforcer), optional:: keywordEnforcer ! must use keywords below
+    character(len=*),       intent(in),   optional  :: prefix
+    type(ESMF_LogMsg_Flag), intent(in),   optional  :: logMsgFlag
+    logical,                intent(in),   optional  :: deepFlag
+    integer, intent(out),                 optional  :: rc
+!
+! !DESCRIPTION:
+!   Write information about {\tt Array} to the ESMF default Log.
+!
+!   The arguments are:
+!   \begin{description}
+!   \item[array]
+!     {\tt ESMF\_Array} object logged.
+!   \item [{[prefix]}]
+!     String to prefix the log message. Default is no prefix.
+!   \item [{[logMsgFlag]}]
+!     Type of log message generated. See section \ref{const:logmsgflag} for
+!     a list of valid message types. Default is {\tt ESMF\_LOGMSG\_INFO}.
+!   \item[{[deepFlag]}]
+!     When set to {\tt .false.} (default), only log top level information about
+!     the Array.
+!     When set to {\tt .true.}, additionally log deep information.
+!   \item[{[rc]}] 
+!     Return code; equals {\tt ESMF\_SUCCESS} if there are no errors.
+!   \end{description}
+!
+!EOP
+!------------------------------------------------------------------------------
+    integer                 :: localrc      ! local return code
+    type(ESMF_LogMsg_Flag)  :: logMsg
+    type(ESMF_Logical)      :: deep
+
+    ! initialize return code; assume routine not implemented
+    localrc = ESMF_RC_NOT_IMPL
+    if (present(rc)) rc = ESMF_RC_NOT_IMPL
+
+    ! Check init status of arguments
+    ESMF_INIT_CHECK_DEEP(ESMF_ArrayGetInit, array, rc)
+
+    ! deal with optionl logMsgFlag
+    logMsg = ESMF_LOGMSG_INFO ! default
+    if (present(logMsgFlag)) logMsg = logMsgFlag
+
+    ! deal with optional deepFlag
+    deep = ESMF_FALSE ! default
+    if (present(deepFlag)) deep = deepFlag
+
+    ! Call into the C++ interface.
+    call c_esmc_arraylog(array, prefix, logMsg, deep, localrc)
+    if (ESMF_LogFoundError(localrc, ESMF_ERR_PASSTHRU, &
+      ESMF_CONTEXT, rcToReturn=rc)) return
+
+    ! return successfully
+    if (present(rc)) rc = ESMF_SUCCESS
+
+  end subroutine ESMF_ArrayLog
+!------------------------------------------------------------------------------
+
+
 ! -------------------------- ESMF-public method -------------------------------
 #undef  ESMF_METHOD
 #define ESMF_METHOD "ESMF_ArrayPrint()"

src/Infrastructure/Array/src/ESMCI_Array.C

@@ -4154,6 +4154,48 @@ int Array::write(
 }
 //-----------------------------------------------------------------------------
 
+//-----------------------------------------------------------------------------
+#undef  ESMC_METHOD
+#define ESMC_METHOD "ESMCI::Array::log()"
+//BOPI
+// !IROUTINE:  ESMCI::Array::log
+//
+// !INTERFACE:
+void Array::log(
+//
+// !DESCRIPTION:
+//    Log details of Array object
+//
+// !ARGUMENTS:
+//
+  std::string prefix,
+  ESMC_LogMsgType_Flag msgType,
+  bool deepFlag
+  )const{
+//
+//EOPI
+//-----------------------------------------------------------------------------
+  std::stringstream msg;
+  msg << prefix << "--- Array::log() start -----------------------------------";
+  ESMC_LogDefault.Write(msg.str(), msgType);
+
+  if (ESMC_BaseGetStatus()!=ESMF_STATUS_READY){
+    msg.str("");  // clear
+    msg << prefix << "Array object is invalid! Not created or deleted!";
+    ESMC_LogDefault.Write(msg.str(), msgType);
+  }else{
+    msg.str("");  // clear
+    msg << prefix << "Array object is valid!"
+      << " <name: " << getName() << ">";
+    ESMC_LogDefault.Write(msg.str(), msgType);
+    if (deepFlag) getDistGrid()->log(prefix+"! ", msgType, deepFlag);
+  }
+  msg.str("");  // clear
+  msg << prefix << "--- Array::log() end -------------------------------------";
+  ESMC_LogDefault.Write(msg.str(), msgType);
+}
+//-----------------------------------------------------------------------------
+
 //-----------------------------------------------------------------------------
 #undef  ESMC_METHOD
 #define ESMC_METHOD "ESMCI::Array::print()"

src/Infrastructure/ArrayBundle/include/ESMCI_ArrayBundle.h

@@ -122,7 +122,7 @@ class ArrayBundle : public ESMC_Base {    // inherits from ESMC_Base class
               int *timeslice, ESMC_IOFmt_Flag *iofmt);
     // misc.
     void log(std::string prefix,
-      ESMC_LogMsgType_Flag msgType=ESMC_LOGMSG_INFO)const;
+      ESMC_LogMsgType_Flag msgType=ESMC_LOGMSG_INFO, bool deepFlag=false)const;
     int print() const;
     // serialize() and deserialize()
     int serialize(char *buffer,int *length,int *offset,

src/Infrastructure/ArrayBundle/interface/ESMCI_ArrayBundle_F.C

@@ -382,14 +382,18 @@ extern "C" {
   }
 
   void FTN_X(c_esmc_arraybundlelog)(ESMCI::ArrayBundle **arraybundle,
-    char *prefix, ESMC_LogMsgType_Flag *logMsgFlag, int *rc,
-    ESMCI_FortranStrLenArg prefix_l){
+    char *prefix, ESMC_LogMsgType_Flag *logMsgFlag, ESMC_Logical *deep,
+    int *rc, ESMCI_FortranStrLenArg prefix_l){
 #undef  ESMC_METHOD
 #define ESMC_METHOD "c_esmc_arraybundlelog()"
     if (rc!=NULL) *rc = ESMC_RC_NOT_IMPL;
+    // convert to bool
+    bool deepFlag = false;  // default
+    if (ESMC_NOT_PRESENT_FILTER(deep) != ESMC_NULL_POINTER)
+      if (*deep == ESMF_TRUE) deepFlag = true;
     try{
       std::string prefixStr(prefix, prefix_l);
-      (*arraybundle)->log(prefixStr, *logMsgFlag);
+      (*arraybundle)->log(prefixStr, *logMsgFlag, deepFlag);
     }catch(int localrc){
       if (ESMC_LogDefault.MsgFoundError(localrc, ESMCI_ERR_PASSTHRU,
         ESMC_CONTEXT, rc))

src/Infrastructure/ArrayBundle/interface/ESMF_ArrayBundle.F90

@@ -1629,20 +1629,25 @@ subroutine ESMF_ArrayBundleLog(arraybundle, keywordEnforcer, prefix, logMsgFlag,
 !------------------------------------------------------------------------------
     integer                 :: localrc      ! local return code
     type(ESMF_LogMsg_Flag)  :: logMsg
+    type(ESMF_Logical)      :: deep
 
     ! initialize return code; assume routine not implemented
     localrc = ESMF_RC_NOT_IMPL
     if (present(rc)) rc = ESMF_RC_NOT_IMPL
 
     ! Check init status of arguments
     ESMF_INIT_CHECK_DEEP_SHORT(ESMF_ArrayBundleGetInit, arraybundle, rc)
-    
-    ! deal with optionl logMsgFlag
+
+    ! deal with optional logMsgFlag
     logMsg = ESMF_LOGMSG_INFO ! default
     if (present(logMsgFlag)) logMsg = logMsgFlag
 
+    ! deal with optional deepFlag
+    deep = ESMF_FALSE ! default
+    if (present(deepFlag)) deep = deepFlag
+
     ! Call into the C++ interface.
-    call c_esmc_arraybundlelog(arraybundle, prefix, logMsg, localrc)
+    call c_esmc_arraybundlelog(arraybundle, prefix, logMsg, deep, localrc)
     if (ESMF_LogFoundError(localrc, ESMF_ERR_PASSTHRU, &
       ESMF_CONTEXT, rcToReturn=rc)) return
 

src/Infrastructure/ArrayBundle/src/ESMCI_ArrayBundle.C

@@ -543,10 +543,17 @@ int ArrayBundle::write(
 // !IROUTINE:  ESMCI::ArrayBundle::log
 //
 // !INTERFACE:
-void ArrayBundle::log(std::string prefix, ESMC_LogMsgType_Flag msgType)const{
+void ArrayBundle::log(
 //
 // !DESCRIPTION:
-//    Log details of ArrayBundle object 
+//    Log details of ArrayBundle object
+//
+// !ARGUMENTS:
+//
+  std::string prefix,
+  ESMC_LogMsgType_Flag msgType,
+  bool deepFlag
+  )const{
 //
 //EOPI
 //-----------------------------------------------------------------------------
@@ -563,10 +570,14 @@ void ArrayBundle::log(std::string prefix, ESMC_LogMsgType_Flag msgType)const{
     msg << prefix << "ArrayBundle object is valid!"
       << " <name: " << getName() << "> <itemCount: " << getCount() << ">";
     ESMC_LogDefault.Write(msg.str(), msgType);
-    for (auto it = arrayContainer.begin(); it != arrayContainer.end(); ++it){
+    int item=0;
+    for (auto it = arrayContainer.begin(); it != arrayContainer.end(); ++it,
+      item++){
       msg.str("");  // clear
-      msg << prefix << "+-<itemName: " << it->second->second->getName() << ">";
+      msg << prefix << "+-<item: " << item << "> <itemName: "
+        << it->second->second->getName() << ">";
       ESMC_LogDefault.Write(msg.str(), msgType);
+      if (deepFlag) it->second->second->log(prefix+"! ", msgType, deepFlag);
     }
   }
   msg.str("");  // clear

src/Infrastructure/ArrayBundle/tests/ESMF_ArrayBundleCreateUTest.F90

@@ -164,7 +164,7 @@ program ESMF_ArrayBundleCreateUTest
   !NEX_UTest
   write(name, *) "ArrayBundleLog #1 Test"
   write(failMsg, *) "Did not return ESMF_SUCCESS"
-  call ESMF_ArrayBundleLog(arraybundle, prefix="#1: ", rc=rc)
+  call ESMF_ArrayBundleLog(arraybundle, prefix="log-#1: ", rc=rc)
   call ESMF_Test((rc.eq.ESMF_SUCCESS), name, failMsg, result, ESMF_SRCLINE)
 
   !------------------------------------------------------------------------
@@ -273,7 +273,7 @@ program ESMF_ArrayBundleCreateUTest
   !NEX_UTest
   write(name, *) "ArrayBundleLog #2 Test"
   write(failMsg, *) "Did not return ESMF_SUCCESS"
-  call ESMF_ArrayBundleLog(arraybundle, prefix="#2: ", rc=rc)
+  call ESMF_ArrayBundleLog(arraybundle, prefix="log-#2: ", rc=rc)
   call ESMF_Test((rc.eq.ESMF_SUCCESS), name, failMsg, result, ESMF_SRCLINE)
 
   !------------------------------------------------------------------------
@@ -469,7 +469,8 @@ program ESMF_ArrayBundleCreateUTest
   !NEX_UTest
   write(name, *) "ArrayBundleLog #3 Test"
   write(failMsg, *) "Did not return ESMF_SUCCESS"
-  call ESMF_ArrayBundleLog(arraybundle, prefix="#3: ", rc=rc)
+  call ESMF_ArrayBundleLog(arraybundle, prefix="log-#3: ", deepFlag=.true., &
+    rc=rc)
   call ESMF_Test((rc.eq.ESMF_SUCCESS), name, failMsg, result, ESMF_SRCLINE)
 
   !------------------------------------------------------------------------

src/Infrastructure/DistGrid/include/ESMCI_DistGrid.h

@@ -314,6 +314,8 @@ namespace ESMCI {
     int fillIndexListPDimPDe(int *indexList, int de, int dim,
       VMK::commhandle **commh, int rootPet, VM *vm=NULL) const;
     // misc.
+    void log(std::string prefix,
+      ESMC_LogMsgType_Flag msgType=ESMC_LOGMSG_INFO, bool deepFlag=false)const;
     static DistGridMatch_Flag match(DistGrid *distgrid1, DistGrid *distgrid2,
       int *rc=NULL);
     int print() const;

src/Infrastructure/DistGrid/interface/ESMCI_DistGrid_F.C

@@ -804,6 +804,36 @@ extern "C" {
     if (rc!=NULL) *rc = ESMF_SUCCESS;
   }
 
+  void FTN_X(c_esmc_distgridlog)(ESMCI::DistGrid **distgrid,
+    char *prefix, ESMC_LogMsgType_Flag *logMsgFlag, ESMC_Logical *deep, int *rc,
+    ESMCI_FortranStrLenArg prefix_l){
+#undef  ESMC_METHOD
+#define ESMC_METHOD "c_esmc_distgridlog()"
+    if (rc!=NULL) *rc = ESMC_RC_NOT_IMPL;
+    // convert to bool
+    bool deepFlag = false;  // default
+    if (ESMC_NOT_PRESENT_FILTER(deep) != ESMC_NULL_POINTER)
+      if (*deep == ESMF_TRUE) deepFlag = true;
+    try{
+      std::string prefixStr(prefix, prefix_l);
+      (*distgrid)->log(prefixStr, *logMsgFlag, deepFlag);
+    }catch(int localrc){
+      if (ESMC_LogDefault.MsgFoundError(localrc, ESMCI_ERR_PASSTHRU,
+        ESMC_CONTEXT, rc))
+        return; // bail out
+    }catch(std::exception &x){
+      ESMC_LogDefault.MsgFoundError(ESMC_RC_INTNRL_BAD, x.what(), ESMC_CONTEXT,
+        rc);
+      return; // bail out
+    }catch(...){
+      ESMC_LogDefault.MsgFoundError(ESMC_RC_INTNRL_BAD, "- Caught exception", 
+        ESMC_CONTEXT, rc);
+      return;
+    }
+    // return successfully
+    if (rc!=NULL) *rc = ESMF_SUCCESS;
+  }
+
   void FTN_X(c_esmc_distgridmatch)(ESMCI::DistGrid **ptr1, ESMCI::DistGrid **ptr2,
     ESMCI::DistGridMatch_Flag *matchResult, int *rc){
 #undef  ESMC_METHOD