Branch data     Line data    Source code

       1                 :            : // *****************************************************************************
       2                 :            : /*!
       3                 :            :   \file      src/Main/WalkerPrint.hpp
       4                 :            :   \copyright 2012-2015 J. Bakosi,
       5                 :            :              2016-2018 Los Alamos National Security, LLC.,
       6                 :            :              2019-2021 Triad National Security, LLC.
       7                 :            :              All rights reserved. See the LICENSE file for details.
       8                 :            :   \brief     Walker-specific pretty printer functionality
       9                 :            :   \details   Walker-specific pretty printer functionality.
      10                 :            : */
      11                 :            : // *****************************************************************************
      12                 :            : #ifndef WalkerPrint_h
      13                 :            : #define WalkerPrint_h
      14                 :            : 
      15                 :            : #include <functional>
      16                 :            : #include <iostream>
      17                 :            : #include <map>
      18                 :            : #include <vector>
      19                 :            : #include <string>
      20                 :            : #include <utility>
      21                 :            : #include <cstddef>
      22                 :            : 
      23                 :            : #include <brigand/algorithms/for_each.hpp>
      24                 :            : 
      25                 :            : #include "NoWarning/format.hpp"
      26                 :            : 
      27                 :            : #include "Keywords.hpp"
      28                 :            : #include "Print.hpp"
      29                 :            : #include "Types.hpp"
      30                 :            : #include "Tags.hpp"
      31                 :            : #include "RNGPrint.hpp"
      32                 :            : #include "ContainerUtil.hpp"
      33                 :            : #include "Walker/Options/DiffEq.hpp"
      34                 :            : #include "Walker/Options/InitPolicy.hpp"
      35                 :            : #include "Walker/Options/CoeffPolicy.hpp"
      36                 :            : #include "Walker/InputDeck/InputDeck.hpp"
      37                 :            : 
      38                 :            : namespace tk { namespace ctr { struct Term; } }
      39                 :            : 
      40                 :            : namespace walker {
      41                 :            : 
      42                 :            : extern ctr::InputDeck g_inputdeck_defaults;
      43                 :            : extern ctr::InputDeck g_inputdeck;
      44                 :            : 
      45                 :            : //! WalkerPrint : tk::RNGPrint
      46                 :            : class WalkerPrint : public tk::RNGPrint {
      47                 :            : 
      48                 :            :   public:
      49                 :            :     //! Constructor
      50                 :            :     //! \param[in] screen Screen output filename
      51                 :            :     //! \param[in,out] str Verbose stream
      52                 :            :     //! \param[in] mode Open mode for screen output file, see
      53                 :            :     //!   http://en.cppreference.com/w/cpp/io/ios_base/openmode
      54                 :            :     //! \param[in,out] qstr Quiet stream
      55                 :            :     //! \see tk::RNGPrint::RNGPrint and tk::Print::Print
      56                 :       1788 :     explicit WalkerPrint( const std::string& screen,
      57                 :            :                           std::ostream& str = std::clog,
      58                 :            :                           std::ios_base::openmode mode = std::ios_base::out,
      59                 :       1788 :                           std::ostream& qstr = std::cout ) :
      60                 :       1788 :       RNGPrint( screen, str, mode, qstr ) {}
      61                 :            : 
      62                 :            :     //! Print section only if differs from its default
      63                 :            :     template< typename Option, typename... tags >
      64                 :            :     void Section() const {
      65                 :            :       if (g_inputdeck.get< tags... >() !=
      66                 :            :             g_inputdeck_defaults.get< tags... >() ) {
      67                 :            :         Option opt;
      68                 :            :         auto& group = opt.group();
      69                 :            :         auto& value = opt.name( g_inputdeck.get< tags... >() );
      70                 :            :         m_stream << m_section_title_value_fmt % m_section_indent
      71                 :            :                                               % m_section_bullet
      72                 :            :                                               % group
      73                 :            :                                               % value;
      74                 :            :         m_stream << m_section_underline_fmt
      75                 :            :                     % m_section_indent
      76                 :            :                     % std::string( m_section_indent.size() + 3 +
      77                 :            :                                    group.size() + value.size(), '-' );
      78                 :            :       }
      79                 :            :     }
      80                 :            : 
      81                 :            :     //! Print item: 'name : value' only if differs from its default
      82                 :            :     //! \param[in] name Name of item
      83                 :            :     template< typename... tags >
      84                 :            :     void Item( const std::string& name ) const {
      85                 :            :       if (g_inputdeck.get< tags... >() !=
      86                 :            :             g_inputdeck_defaults.get< tags... >() )
      87                 :            :         m_stream << m_item_name_value_fmt
      88                 :            :                     % m_item_indent % name % g_inputdeck.get<tags...>();
      89                 :            :     }
      90                 :            : 
      91                 :            :     //! Print control option: 'group : option' only if differs from its default
      92                 :            :     template<typename Option, typename... tags>
      93                 :            :     void Item() const {
      94                 :            :       if (g_inputdeck.get< tags... >() !=
      95                 :            :             g_inputdeck_defaults.get< tags... >() ) {
      96                 :            :         Option opt;
      97                 :            :         m_stream << m_item_name_value_fmt
      98                 :            :                     % m_item_indent % opt.group()
      99                 :            :                     % opt.name( g_inputdeck.get< tags... >() );
     100                 :            :       }
     101                 :            :     }
     102                 :            : 
     103                 :            :     // Helper class for compact output of diff eq policies
     104                 :            :     class Policies {
     105                 :            :       public:
     106                 :            :         // Default constructor
     107                 :            :         explicit Policies() : init(), coef() {}
     108                 :            :         // Initializer constructor
     109                 :            :         explicit Policies( const std::string& i, const std::string& c ) :
     110                 :            :           init(i), coef(c) {}
     111                 :            :         // Operator += for adding up two Policies structs
     112                 :            :         Policies& operator+= ( const Policies& p ) {
     113                 :            :           init += p.init;
     114                 :            :           coef += p.coef;
     115                 :            :           return *this;
     116                 :            :         }
     117                 :            :         // Output unique policies to output stream
     118                 :            :         friend std::ostream& operator<< ( std::ostream& os, const Policies& p )
     119                 :            :         {
     120                 :            :           Policies copy( p );     // copy policies
     121                 :            :           copy.unique();          // get rid of duplicate policies
     122                 :            :           os << "i:" << copy.init << ", c:" << copy.coef;
     123                 :            :           return os;
     124                 :            :         }
     125                 :            : 
     126                 :            :       private:
     127                 :            :         // Make all policies unique
     128                 :            :         void unique() {
     129                 :            :           tk::unique( init );
     130                 :            :           tk::unique( coef );
     131                 :            :         }
     132                 :            : 
     133                 :            :         std::string init;
     134                 :            :         std::string coef;
     135                 :            :     };
     136                 :            : 
     137                 :            :     //! Print time integration header
     138                 :            :     void inthead( const std::string& t, const std::string& name,
     139                 :            :                   const std::string& legend, const std::string& head ) const;
     140                 :            : 
     141                 :            :     //! Print statistics and PDFs
     142                 :            :     void statistics( const std::string& t ) const;
     143                 :            : 
     144                 :            :     //! Print configuration of a stack of differential equations
     145                 :            :     void diffeqs( const std::string& t,
     146                 :            :       const std::vector< std::vector< std::pair< std::string, std::string > > >&
     147                 :            :         info ) const;
     148                 :            : 
     149                 :            :   private:
     150                 :            :     //! Return differential equation name
     151                 :            :     //! \param[in] key Equation key
     152                 :            :     //! \return Differential equation name based on key
     153                 :            :     template< class Key >
     154                 :            :     std::string DiffEqName ( const Key& key ) const
     155                 :            :     { return ctr::DiffEq().name( key.template get< tag::diffeq >() ); }
     156                 :            : 
     157                 :            :     //! Echo statistics container contents if differs from default
     158                 :            :     void stats( const std::string& msg ) const;
     159                 :            : 
     160                 :            :     //! Echo pdfs container contents if differs from default applying op
     161                 :            :     void pdfs( const std::string& msg,
     162                 :            :                std::function<
     163                 :            :                  std::ostream& ( std::ostream&,
     164                 :            :                                  const std::vector< tk::ctr::Term >&,
     165                 :            :                                  const std::vector< tk::real >&,
     166                 :            :                                  const std::string&,
     167                 :            :                                  const std::vector< tk::real >& ) > op ) const;
     168                 :            : };
     169                 :            : 
     170                 :            : } // walker::
     171                 :            : 
     172                 :            : #endif // WalkerPrint_h