Try to make log output more readable

src/coreComponents/constitutive/contact/ContactBase.cpp

@@ -104,6 +104,12 @@ void ContactBase::allocateConstitutiveData( Group & parent,
   // this check is necessary to ensure that the coordinates are strictly increasing
   if( apertureTransition > apertureValues[apertureValues.size()-1] )
   {
+    GEOS_LOG( GEOS_FMT ( "Adding aperture transition for table {}:", m_apertureTableName ) );
+    std::ostringstream s_orig;
+    for( localIndex i = 0; i < apertureValues.size(); i++ )
+      s_orig << "[ " << apertureValues[i] << ", " << hydraulicApertureValues[i] << " ] ";
+    GEOS_LOG( GEOS_FMT ( "    Original table = {}", s_orig.str()));
+
     coords.emplaceBack( 0, apertureTransition );
     hydraulicApertureValues.emplace_back( apertureTransition );
     // if the aperture transition is larger than 0, we keep enlarging the table
@@ -114,6 +120,11 @@ void ContactBase::allocateConstitutiveData( Group & parent,
       hydraulicApertureValues.emplace_back( apertureTransition*10e9 );
       apertureTable.reInitializeFunction();
     }
+
+    std::ostringstream s_mod;
+    for( localIndex i = 0; i < apertureValues.size(); i++ )
+      s_mod << "[ " << apertureValues[i] << ", " << hydraulicApertureValues[i] << " ] ";
+    GEOS_LOG( GEOS_FMT ( "    Modified table = {}", s_mod.str()));
   }
 
   m_apertureTable = &apertureTable;

src/coreComponents/events/EventManager.cpp

@@ -179,9 +179,8 @@ bool EventManager::run( DomainPartition & domain )
       subEvent->checkEvents( m_time, m_dt, m_cycle, domain );
 
       // Print debug information for logLevel >= 1
-      GEOS_LOG_LEVEL_RANK_0( 1,
-                             "     Event: " << m_currentSubEvent << " (" << subEvent->getName() << "), dt_request=" << subEvent->getCurrentEventDtRequest() << ", forecast=" <<
-                             subEvent->getForecast() );
+      GEOS_LOG_LEVEL_RANK_0( 1, GEOS_FMT( "Event: {} ({}), dt_request={}, forecast={}",
+                                          m_currentSubEvent, subEvent->getName(), subEvent->getCurrentEventDtRequest(), subEvent->getForecast() ) );
 
       // Execute, signal events
       bool earlyReturn = false;

src/coreComponents/linearAlgebra/interfaces/direct/SuiteSparse.cpp

@@ -283,7 +283,7 @@ void SuiteSparse< LAI >::solve( Vector const & rhs,
 
   if( m_params.logLevel >= 1 )
   {
-    GEOS_LOG_RANK_0( "\t\tLinear Solver | " << m_result.status <<
+    GEOS_LOG_RANK_0( "        Linear Solver | " << m_result.status <<
                      " | Iterations: " << m_result.numIterations <<
                      " | Final Rel Res: " << m_result.residualReduction <<
                      " | Setup Time: " << m_result.setupTime << " s" <<

src/coreComponents/linearAlgebra/interfaces/direct/SuperLUDist.cpp

@@ -298,7 +298,7 @@ void SuperLUDist< LAI >::solve( Vector const & rhs,
 
   if( m_params.logLevel >= 1 )
   {
-    GEOS_LOG_RANK_0( "\t\tLinear Solver | " << m_result.status <<
+    GEOS_LOG_RANK_0( "        Linear Solver | " << m_result.status <<
                      " | Iterations: " << m_result.numIterations <<
                      " | Final Rel Res: " << m_result.residualReduction <<
                      " | Setup Time: " << m_result.setupTime << " s" <<

src/coreComponents/linearAlgebra/interfaces/hypre/HypreMGR.cpp

@@ -65,11 +65,11 @@ void hypre::mgr::createMGR( LinearSolverParameters const & params,
 
   if( params.logLevel >= 1 )
   {
-    GEOS_LOG_RANK_0( numComponentsPerField );
+    GEOS_LOG_RANK_0( GEOS_FMT( "        MGR preconditioner: numComponentsPerField = {}", numComponentsPerField ) );
   }
   if( params.logLevel >= 4 )
   {
-    GEOS_LOG_RANK_VAR( mgrData.pointMarkers );
+    GEOS_LOG_RANK( GEOS_FMT( "        MGR preconditioner: pointMarkers = {}", mgrData.pointMarkers ) );
   }
 
   switch( params.mgr.strategy )

src/coreComponents/linearAlgebra/interfaces/hypre/HypreSolver.cpp

@@ -275,7 +275,7 @@ void HypreSolver::solve( HypreVector const & rhs,
 
   if( m_params.logLevel >= 1 )
   {
-    GEOS_LOG_RANK_0( "\t\tLinear Solver | " << m_result.status <<
+    GEOS_LOG_RANK_0( "        Linear Solver | " << m_result.status <<
                      " | Iterations: " << m_result.numIterations <<
                      " | Final Rel Res: " << m_result.residualReduction <<
                      " | Make Restrictor Time: " << m_makeRestrictorTime <<

src/coreComponents/linearAlgebra/interfaces/petsc/PetscSolver.cpp

@@ -148,7 +148,7 @@ void PetscSolver::solve( PetscVector const & rhs,
 
   if( m_params.logLevel >= 1 )
   {
-    GEOS_LOG_RANK_0( "\t\tLinear Solver | " << m_result.status <<
+    GEOS_LOG_RANK_0( "        Linear Solver | " << m_result.status <<
                      " | Iterations: " << m_result.numIterations <<
                      " | Final Rel Res: " << m_result.residualReduction <<
                      " | Setup Time: " << m_result.setupTime << " s" <<

src/coreComponents/linearAlgebra/interfaces/trilinos/TrilinosSolver.cpp

@@ -156,7 +156,7 @@ void TrilinosSolver::solve( EpetraVector const & rhs,
 
   if( m_params.logLevel >= 1 )
   {
-    GEOS_LOG_RANK_0( "\t\tLinear Solver | " << m_result.status <<
+    GEOS_LOG_RANK_0( "        Linear Solver | " << m_result.status <<
                      " | Iterations: " << m_result.numIterations <<
                      " | Final Rel Res: " << m_result.residualReduction <<
                      " | Setup Time: " << m_result.setupTime << " s" <<

src/coreComponents/physicsSolvers/SolverBase.cpp

@@ -524,11 +524,7 @@ bool SolverBase::lineSearch( real64 const & time_n,
 
       // get residual norm
       residualNorm = calculateResidualNorm( time_n, dt, domain, dofManager, rhs.values() );
-    }
-
-    if( getLogLevel() >= 1 && logger::internal::rank==0 )
-    {
-      std::cout << std::endl;
+      GEOS_LOG_LEVEL_RANK_0( 1, GEOS_FMT( "        ( R ) = ( {:4.2e} )", residualNorm ) );
     }
 
     // if the residual norm is less than the last residual, we can proceed to the
@@ -639,6 +635,7 @@ bool SolverBase::lineSearchWithParabolicInterpolation( real64 const & time_n,
 
       // get residual norm
       residualNormT = calculateResidualNorm( time_n, dt, domain, dofManager, rhs.values() );
+      GEOS_LOG_LEVEL_RANK_0( 1, GEOS_FMT( "        ( R ) = ( {:4.2e} )", residualNormT ) );
     }
     ffm = ffT;
     ffT = residualNormT*residualNormT;
@@ -764,9 +761,7 @@ real64 SolverBase::nonlinearImplicitStep( real64 const & time_n,
           // increment the solver statistics for reporting purposes
           m_solverStatistics.logOuterLoopIteration();
 
-          GEOS_LOG_LEVEL_RANK_0( 1, "   " );
           GEOS_LOG_LEVEL_RANK_0( 1, "---------- Configuration did not converge. Testing new configuration. ----------" );
-          GEOS_LOG_LEVEL_RANK_0( 1, "   " );
         }
       }
       else if( !attemptedSimplestConfiguration )
@@ -884,12 +879,12 @@ bool SolverBase::solveNonlinearSystem( real64 const & time_n,
 
       // get residual norm
       residualNorm = calculateResidualNorm( time_n, stepDt, domain, m_dofManager, m_rhs.values() );
-      GEOS_LOG_LEVEL_RANK_0( 1, GEOS_FMT( "    ( R ) = ( {:4.2e} ) ; ", residualNorm ) );
+      GEOS_LOG_LEVEL_RANK_0( 1, GEOS_FMT( "        ( R ) = ( {:4.2e} )", residualNorm ) );
     }
 
     if( newtonIter > 0 )
     {
-      GEOS_LOG_LEVEL_RANK_0( 1, GEOS_FMT( "    Last LinSolve(iter,res) = ( {:3}, {:4.2e} ) ; ",
+      GEOS_LOG_LEVEL_RANK_0( 1, GEOS_FMT( "        Last LinSolve(iter,res) = ( {:3}, {:4.2e} )",
                                           m_linearSolverResult.numIterations,
                                           m_linearSolverResult.residualReduction ) );
     }
@@ -1008,7 +1003,7 @@ bool SolverBase::solveNonlinearSystem( real64 const & time_n,
 
       if( getLogLevel() >= 1 )
       {
-        GEOS_LOG_RANK_0( getName() + ": Global solution scaling factor = " << scaleFactor );
+        GEOS_LOG_RANK_0( GEOS_FMT( "        {}: Global solution scaling factor = {}", getName(), scaleFactor ) );
       }
 
       if( !checkSystemSolution( domain, m_dofManager, m_solution.values(), scaleFactor ) )

src/coreComponents/physicsSolvers/contact/LagrangianContactSolver.cpp

@@ -258,8 +258,6 @@ void LagrangianContactSolver::implicitStepComplete( real64 const & time_n,
                                                          true );
 
   } );
-
-  GEOS_LOG_LEVEL_RANK_0( 1, " ***** ImplicitStepComplete *****" );
 }
 
 void LagrangianContactSolver::postProcessInput()
@@ -708,10 +706,14 @@ real64 LagrangianContactSolver::calculateResidualNorm( real64 const & GEOS_UNUSE
     // Add 0 just to match Matlab code results
     globalResidualNorm[2] /= (m_initialResidual[2]+1.0);
   }
-  GEOS_LOG_LEVEL_RANK_0( 1, GEOS_FMT( "    ( Rdisplacement, Rtraction, Rtotal ) = ( {:15.6e}, {:15.6e}, {:15.6e} );",
-                                      globalResidualNorm[0],
-                                      globalResidualNorm[1],
-                                      globalResidualNorm[2] ) );
+  if( getLogLevel() >= 1 && logger::internal::rank == 0 )
+  {
+    std::cout<< GEOS_FMT(
+      "        ( Rdisplacement, Rtraction, Rtotal ) = ( {:15.6e}, {:15.6e}, {:15.6e} )",
+      globalResidualNorm[0],
+      globalResidualNorm[1],
+      globalResidualNorm[2] );
+  }
   return globalResidualNorm[2];
 }
 

src/coreComponents/physicsSolvers/contact/SolidMechanicsEmbeddedFractures.cpp

@@ -632,7 +632,7 @@ real64 SolidMechanicsEmbeddedFractures::calculateResidualNorm( real64 const & ti
 
     if( getLogLevel() >= 1 && logger::internal::rank==0 )
     {
-      std::cout << GEOS_FMT( "( RFracture ) = ( {:4.2e} ) ; ", fractureResidualNorm );
+      std::cout << GEOS_FMT( "        ( RFracture ) = ( {:4.2e} )", fractureResidualNorm );
     }
 
     return sqrt( solidResidualNorm * solidResidualNorm + fractureResidualNorm * fractureResidualNorm );

src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseFVM.cpp

@@ -334,7 +334,7 @@ real64 CompositionalMultiphaseFVM::calculateResidualNorm( real64 const & GEOS_UN
 
     if( getLogLevel() >= 1 && logger::internal::rank == 0 )
     {
-      std::cout << GEOS_FMT( "    ( R{} ) = ( {:4.2e} ) ; ( Renergy ) = ( {:4.2e} ) ; ",
+      std::cout << GEOS_FMT( "        ( R{} ) = ( {:4.2e} )        ( Renergy ) = ( {:4.2e} )",
                              coupledSolverAttributePrefix(), globalResidualNorm[0], globalResidualNorm[1] );
     }
   }
@@ -352,7 +352,7 @@ real64 CompositionalMultiphaseFVM::calculateResidualNorm( real64 const & GEOS_UN
 
     if( getLogLevel() >= 1 && logger::internal::rank == 0 )
     {
-      std::cout << GEOS_FMT( "    ( R{} ) = ( {:4.2e} ) ; ", coupledSolverAttributePrefix(), residualNorm );
+      std::cout << GEOS_FMT( "        ( R{} ) = ( {:4.2e} )", coupledSolverAttributePrefix(), residualNorm );
     }
   }
   return residualNorm;
@@ -431,18 +431,18 @@ real64 CompositionalMultiphaseFVM::scalingForSystemSolution( DomainPartition & d
 
   if( m_isThermal )
   {
-    GEOS_LOG_LEVEL_RANK_0( 1, getName() + ": Max deltaPres  = " << maxDeltaPres  << ", Max deltaCompDens = " << maxDeltaCompDens << ", Max deltaTemp = " << maxDeltaTemp << " (before scaling)" );
+    GEOS_LOG_LEVEL_RANK_0( 1, GEOS_FMT( "        {}: Max deltaPres  = {}, Max deltaCompDens = {}, Max deltaTemp = {} (before scaling)", getName(), maxDeltaPres, maxDeltaCompDens, maxDeltaTemp ) );
   }
   else
   {
-    GEOS_LOG_LEVEL_RANK_0( 1, getName() + ": Max deltaPres  = " << maxDeltaPres  << ", Max deltaCompDens = " << maxDeltaCompDens << " (before scaling)" );
+    GEOS_LOG_LEVEL_RANK_0( 1, GEOS_FMT( "        {}: Max deltaPres  = {}, Max deltaCompDens = {} (before scaling)", getName(), maxDeltaPres, maxDeltaCompDens ) );
   }
   if( m_scalingType == ScalingType::Local )
   {
-    GEOS_LOG_LEVEL_RANK_0( 1, getName() + ": Min pressure scaling factor = " << minPresScalingFactor );
-    GEOS_LOG_LEVEL_RANK_0( 1, getName() + ": Min comp dens scaling factor = " << minCompDensScalingFactor );
+    GEOS_LOG_LEVEL_RANK_0( 1, GEOS_FMT( "        {}: Min pressure scaling factor = {}", getName(), minPresScalingFactor ) );
+    GEOS_LOG_LEVEL_RANK_0( 1, GEOS_FMT( "        {}: Min comp dens scaling factor = {}", getName(), minCompDensScalingFactor ) );
     if( m_isThermal )
-      GEOS_LOG_LEVEL_RANK_0( 1, getName() + ": Min temperature scaling factor = " << minTempScalingFactor );
+      GEOS_LOG_LEVEL_RANK_0( 1, GEOS_FMT( "        {}: Min temperature scaling factor = {}", getName(), minTempScalingFactor ) );
   }
 
   return LvArray::math::max( scalingFactor, m_minScalingFactor );

src/coreComponents/physicsSolvers/fluidFlow/CompositionalMultiphaseHybridFVM.cpp

@@ -706,7 +706,7 @@ real64 CompositionalMultiphaseHybridFVM::calculateResidualNorm( real64 const & G
 
   if( getLogLevel() >= 1 && logger::internal::rank == 0 )
   {
-    std::cout << GEOS_FMT( "    ( R{} ) = ( {:4.2e} ) ; ", coupledSolverAttributePrefix(), residualNorm );
+    std::cout << GEOS_FMT( "        ( R{} ) = ( {:4.2e} )", coupledSolverAttributePrefix(), residualNorm );
   }
 
   return residualNorm;

src/coreComponents/physicsSolvers/fluidFlow/ReactiveCompositionalMultiphaseOBL.cpp

@@ -364,7 +364,10 @@ real64 ReactiveCompositionalMultiphaseOBL::calculateResidualNorm( real64 const &
 
   real64 const residual = m_useDARTSL2Norm ? MpiWrapper::max( localResidualNorm ) : std::sqrt( MpiWrapper::sum( localResidualNorm ) );
 
-  GEOS_LOG_LEVEL_RANK_0( 1, GEOS_FMT( "    ( Rflow ) = ( {:4.2e} ) ;", residual ) );
+  if( getLogLevel() >= 1 && logger::internal::rank==0 )
+  {
+    std::cout << GEOS_FMT( "        ( Rflow ) = ( {:4.2e} )", residual );
+  }
 
   return residual;
 }

src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseFVM.cpp

@@ -228,7 +228,7 @@ real64 SinglePhaseFVM< BASE >::calculateResidualNorm( real64 const & GEOS_UNUSED
 
     if( getLogLevel() >= 1 && logger::internal::rank == 0 )
     {
-      std::cout << GEOS_FMT( "    ( R{} ) = ( {:4.2e} ) ; ( Renergy ) = ( {:4.2e} ) ; ",
+      std::cout << GEOS_FMT( "        ( R{} ) = ( {:4.2e} )        ( Renergy ) = ( {:4.2e} )",
                              FlowSolverBase::coupledSolverAttributePrefix(), globalResidualNorm[0], globalResidualNorm[1] );
     }
   }
@@ -246,7 +246,7 @@ real64 SinglePhaseFVM< BASE >::calculateResidualNorm( real64 const & GEOS_UNUSED
 
     if( getLogLevel() >= 1 && logger::internal::rank == 0 )
     {
-      std::cout << GEOS_FMT( "    ( R{} ) = ( {:4.2e} ) ; ", FlowSolverBase::coupledSolverAttributePrefix(), residualNorm );
+      std::cout << GEOS_FMT( "        ( R{} ) = ( {:4.2e} )", FlowSolverBase::coupledSolverAttributePrefix(), residualNorm );
     }
   }
   return residualNorm;

src/coreComponents/physicsSolvers/fluidFlow/SinglePhaseHybridFVM.cpp

@@ -561,7 +561,7 @@ real64 SinglePhaseHybridFVM::calculateResidualNorm( real64 const & GEOS_UNUSED_P
 
   if( getLogLevel() >= 1 && logger::internal::rank == 0 )
   {
-    std::cout << GEOS_FMT( "    ( R{} ) = ( {:4.2e} ) ; ", coupledSolverAttributePrefix(), residualNorm );
+    std::cout << GEOS_FMT( "        ( R{} ) = ( {:4.2e} )", coupledSolverAttributePrefix(), residualNorm );
   }
 
   return residualNorm;

src/coreComponents/physicsSolvers/fluidFlow/proppantTransport/ProppantTransport.cpp

@@ -489,11 +489,10 @@ void ProppantTransport::implicitStepComplete( real64 const & GEOS_UNUSED_PARAM(
 void ProppantTransport::setupDofs( DomainPartition const & GEOS_UNUSED_PARAM( domain ),
                                    DofManager & dofManager ) const
 {
-
-  for( auto const & meshTarget : getMeshTargets() )
+  for( auto const & meshTarget: getMeshTargets())
   {
-    printf( "(%s,%s):", meshTarget.first.first.c_str(), meshTarget.first.second.c_str() );
-    std::cout<<meshTarget.second<<std::endl;
+    GEOS_LOG_RANK_0( GEOS_FMT( "{}: MeshBody = ({},{}) - target region = {}",
+                               getName(), meshTarget.first.first.c_str(), meshTarget.first.second.c_str(), meshTarget.second ));
   }
 
   dofManager.addField( fields::proppant::proppantConcentration::key(),
@@ -895,7 +894,7 @@ ProppantTransport::calculateResidualNorm( real64 const & GEOS_UNUSED_PARAM( time
 
   if( getLogLevel() >= 1 && logger::internal::rank == 0 )
   {
-    std::cout << GEOS_FMT( "    ( R{} ) = ( {:4.2e} ) ; ", ProppantTransport::coupledSolverAttributePrefix(), residualNorm );
+    std::cout << GEOS_FMT( "        ( R{} ) = ( {:4.2e} )", ProppantTransport::coupledSolverAttributePrefix(), residualNorm );
   }
 
   return residualNorm;

src/coreComponents/physicsSolvers/fluidFlow/wells/CompositionalMultiphaseWell.cpp

@@ -1227,7 +1227,7 @@ CompositionalMultiphaseWell::calculateResidualNorm( real64 const & time_n,
 
   if( getLogLevel() >= 1 && logger::internal::rank == 0 )
   {
-    std::cout << GEOS_FMT( "    ( R{} ) = ( {:4.2e} ) ; ", coupledSolverAttributePrefix(), residualNorm );
+    std::cout << GEOS_FMT( "        ( R{} ) = ( {:4.2e} )", coupledSolverAttributePrefix(), residualNorm );
   }
   return residualNorm;
 }

src/coreComponents/physicsSolvers/fluidFlow/wells/SinglePhaseWell.cpp

@@ -840,7 +840,7 @@ SinglePhaseWell::calculateResidualNorm( real64 const & time_n,
 
   if( getLogLevel() >= 1 && logger::internal::rank == 0 )
   {
-    std::cout << GEOS_FMT( "    ( R{} ) = ( {:4.2e} ) ; ", coupledSolverAttributePrefix(), residualNorm );
+    std::cout << GEOS_FMT( "        ( R{} ) = ( {:4.2e} )", coupledSolverAttributePrefix(), residualNorm );
   }
   return residualNorm;
 }

src/coreComponents/physicsSolvers/multiphysics/CoupledSolver.hpp

@@ -78,12 +78,15 @@ class CoupledSolver : public SolverBase
     {
       using SolverPtr = TYPEOFREF( solver );
       using SolverType = TYPEOFPTR( SolverPtr {} );
-      solver = this->getParent().template getGroupPointer< SolverType >( m_names[idx()] );
+      auto const & solverName = m_names[idx()];
+      auto const & solverType = LvArray::system::demangleType< SolverType >();
+      solver = this->getParent().template getGroupPointer< SolverType >( solverName );
       GEOS_THROW_IF( solver == nullptr,
                      GEOS_FMT( "{}: Could not find solver '{}' of type {}",
                                getDataContext(),
-                               m_names[idx()], LvArray::system::demangleType< SolverType >() ),
+                               solverName, solverType ),
                      InputError );
+      GEOS_LOG_LEVEL_RANK_0( 1, GEOS_FMT( "{}: found {} solver named {}", getName(), solver->catalogName(), solverName ) );
     } );
   }
 
@@ -479,7 +482,7 @@ class CoupledSolver : public SolverBase
 
     if( params.m_subcyclingOption == 0 )
     {
-      GEOS_LOG_LEVEL_RANK_0( 1, "***** Single Pass solver, no subcycling *****\n" );
+      GEOS_LOG_LEVEL_RANK_0( 1, "***** Single Pass solver, no subcycling *****" );
     }
     else
     {
@@ -523,7 +526,7 @@ class CoupledSolver : public SolverBase
 
         // finally, we perform the convergence check on the multiphysics residual
         residualNorm = sqrt( residualNorm );
-        GEOS_LOG_LEVEL_RANK_0( 1, GEOS_FMT( "    ( R ) = ( {:4.2e} ) ; ", residualNorm ) );
+        GEOS_LOG_LEVEL_RANK_0( 1, GEOS_FMT( "        ( R ) = ( {:4.2e} )", residualNorm ) );
         isConverged = ( residualNorm < params.m_newtonTol );
 
       }
@@ -545,7 +548,7 @@ class CoupledSolver : public SolverBase
 
       if( isConverged )
       {
-        GEOS_LOG_LEVEL_RANK_0( 1, "***** The iterative coupling has converged in " << iter + 1 << " iteration(s)! *****\n" );
+        GEOS_LOG_LEVEL_RANK_0( 1, GEOS_FMT( "***** The iterative coupling has converged in {} iteration(s) *****", iter + 1 ) );
       }
     }
     return isConverged;

src/coreComponents/physicsSolvers/multiphysics/FlowProppantTransportSolver.cpp

@@ -101,7 +101,7 @@ real64 FlowProppantTransportSolver::sequentiallyCoupledSolverStep( real64 const
       resetStateToBeginningOfStep( domain );
     }
 
-    GEOS_LOG_LEVEL_RANK_0( 1, "\tIteration: " << iter+1  << ", FlowSolver: " );
+    GEOS_LOG_LEVEL_RANK_0( 1, "  Iteration: " << iter+1  << ", FlowSolver: " );
 
     dtReturnTemporary = flowSolver()->nonlinearImplicitStep( time_n, dtReturn, cycleNumber, domain );
 
@@ -116,11 +116,11 @@ real64 FlowProppantTransportSolver::sequentiallyCoupledSolverStep( real64 const
     if( fluidNonLinearParams.m_numNewtonIterations <= this->m_nonlinearSolverParameters.m_minIterNewton && iter > 0 )
     {
       m_solverStatistics.logNonlinearIteration();
-      GEOS_LOG_LEVEL_RANK_0( 1, "***** The iterative coupling has converged in " << iter  << " iterations! *****\n" );
+      GEOS_LOG_LEVEL_RANK_0( 1, GEOS_FMT( "***** The iterative coupling has converged in {} iterations *****", iter ) );
       break;
     }
 
-    GEOS_LOG_LEVEL_RANK_0( 1, "\tIteration: " << iter+1  << ", Proppant Solver: " );
+    GEOS_LOG_LEVEL_RANK_0( 1, GEOS_FMT( "  Iteration: {}, Proppant Solver: ", iter+1 ) );
 
     dtReturnTemporary = proppantTransportSolver()->nonlinearImplicitStep( time_n, dtReturn, cycleNumber, domain );
 

src/coreComponents/physicsSolvers/multiphysics/HydrofractureSolver.cpp

@@ -187,6 +187,8 @@ real64 HydrofractureSolver< POROMECHANICS_SOLVER >::fullyCoupledSolverStep( real
   int solveIter;
   for( solveIter=0; solveIter<maxIter; ++solveIter )
   {
+    GEOS_LOG_RANK_0( GEOS_FMT( "  Fracture propagation iteration {}", solveIter ) );
+
     int locallyFractured = 0;
     int globallyFractured = 0;