Branch data     Line data    Source code

       1                 :            : // *****************************************************************************
       2                 :            : /*!
       3                 :            :   \file      src/Walker/Distributor.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     Distributor drives the time integration of differential equations
       9                 :            :   \details   Distributor drives the time integration of differential equations.
      10                 :            :     The implementation uses the Charm++ runtime system and is fully
      11                 :            :     asynchronous, overlapping computation, communication as well as I/O. The
      12                 :            :     algorithm utilizes the structured dagger (SDAG) Charm++ functionality. The
      13                 :            :     high-level overview of the algorithm structure and how it interfaces with
      14                 :            :     Charm++ is discussed in the Charm++ interface file
      15                 :            :     src/Walker/distributor.ci.
      16                 :            : */
      17                 :            : // *****************************************************************************
      18                 :            : #ifndef Distributor_h
      19                 :            : #define Distributor_h
      20                 :            : 
      21                 :            : #include <vector>
      22                 :            : #include <map>
      23                 :            : #include <iosfwd>
      24                 :            : #include <cstdint>
      25                 :            : 
      26                 :            : #include "Types.hpp"
      27                 :            : #include "Timer.hpp"
      28                 :            : #include "Tags.hpp"
      29                 :            : #include "Table.hpp"
      30                 :            : #include "TaggedTuple.hpp"
      31                 :            : #include "StatCtr.hpp"
      32                 :            : #include "UniPDF.hpp"
      33                 :            : #include "BiPDF.hpp"
      34                 :            : #include "TriPDF.hpp"
      35                 :            : #include "WalkerPrint.hpp"
      36                 :            : #include "Walker/CmdLine/CmdLine.hpp"
      37                 :            : 
      38                 :            : #include "NoWarning/integrator.decl.h"
      39                 :            : 
      40                 :            : namespace walker {
      41                 :            : 
      42                 :            : //! Distributor drives the time integration of differential equations
      43                 :            : // cppcheck-suppress noConstructor
      44                 :            : class Distributor : public CBase_Distributor {
      45                 :            : 
      46                 :            :   #if defined(__clang__)
      47                 :            :     #pragma clang diagnostic push
      48                 :            :     #pragma clang diagnostic ignored "-Wunused-parameter"
      49                 :            :     #pragma clang diagnostic ignored "-Wdeprecated-declarations"
      50                 :            :   #elif defined(STRICT_GNUC)
      51                 :            :     #pragma GCC diagnostic push
      52                 :            :     #pragma GCC diagnostic ignored "-Wunused-parameter"
      53                 :            :     #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
      54                 :            :   #elif defined(__INTEL_COMPILER)
      55                 :            :     #pragma warning( push )
      56                 :            :     #pragma warning( disable: 1478 )
      57                 :            :   #endif
      58                 :            :   // Include Charm++ SDAG code. See http://charm.cs.illinois.edu/manuals/html/
      59                 :            :   // charm++/manual.html, Sec. "Structured Control Flow: Structured Dagger".
      60                 :            :   Distributor_SDAG_CODE
      61                 :            :   #if defined(__clang__)
      62                 :            :     #pragma clang diagnostic pop
      63                 :            :   #elif defined(STRICT_GNUC)
      64                 :            :     #pragma GCC diagnostic pop
      65                 :            :   #elif defined(__INTEL_COMPILER)
      66                 :            :     #pragma warning( pop )
      67                 :            :   #endif
      68                 :            : 
      69                 :            :   public:
      70                 :            :     //! Constructor
      71                 :            :     explicit Distributor();
      72                 :            : 
      73                 :            :     //! \brief Reduction target indicating that all Integrator chares have
      74                 :            :     //!   registered with the statistics merger (collector)
      75                 :            :     //! \details This function is a Charm++ reduction target that is called when
      76                 :            :     //!   all Integrator chares have registered with their local branch of the
      77                 :            :     //!   statistics merger group, Collector. Once this is done, we issue a
      78                 :            :     //!   broadcast to all Itegrator chares to continue with their setup.
      79                 :         93 :     void registered() { m_intproxy.setup( m_dt, m_t, m_it, m_moments ); }
      80                 :            : 
      81                 :            :     //! Estimate ordinary moments
      82                 :            :     void estimateOrd( tk::real* ord, int n );
      83                 :            : 
      84                 :            :     //! Estimate central moments
      85                 :            :     void estimateCen( tk::real* cen, int n );
      86                 :            : 
      87                 :            :     //! Estimate ordinary PDFs
      88                 :            :     void estimateOrdPDF( CkReductionMsg* msg );
      89                 :            : 
      90                 :            :     //! Finish estimation of central PDFs
      91                 :            :     void estimateCenPDF( CkReductionMsg* msg );
      92                 :            : 
      93                 :            :     //! Charm++ reduction target enabling shortcutting sync points if no stats
      94                 :            :     void nostat();
      95                 :            : 
      96                 :            :   private:
      97                 :            :     //! Type alias for output indicators
      98                 :            :     using OutputIndicators = tk::TaggedTuple< brigand::list<
      99                 :            :                                  tag::stat,      bool
     100                 :            :                                , tag::pdf,       bool
     101                 :            :                              > >;
     102                 :            : 
     103                 :            :     OutputIndicators m_output;                  //!< Output indicators
     104                 :            :     uint64_t m_it;                              //!< Iteration count
     105                 :            :     tk::real m_npar;                            //!< Total number of particles
     106                 :            :     tk::real m_t;                               //!< Physical time
     107                 :            :     tk::real m_dt;                              //!< Physical time step size
     108                 :            :     CProxy_Integrator m_intproxy;               //!< Integrator array proxy
     109                 :            :     std::vector< tk::Timer > m_timer;           //!< Timers
     110                 :            :     std::vector< std::string > m_nameOrdinary;  //!< Ordinary moment names
     111                 :            :     std::vector< std::string > m_nameCentral;   //!< Central moment names
     112                 :            :     std::vector< tk::real > m_ordinary;         //!< Ordinary moments
     113                 :            :     std::vector< tk::real > m_central;          //!< Central moments
     114                 :            :     std::vector< tk::UniPDF > m_ordupdf;        //!< Ordinary univariate PDFs
     115                 :            :     std::vector< tk::BiPDF > m_ordbpdf;         //!< Ordinary bivariate PDFs
     116                 :            :     std::vector< tk::TriPDF > m_ordtpdf;        //!< Ordinary trivariate PDFs
     117                 :            :     std::vector< tk::UniPDF > m_cenupdf;        //!< Central univariate PDFs
     118                 :            :     std::vector< tk::BiPDF > m_cenbpdf;         //!< Central bivariate PDFs
     119                 :            :     std::vector< tk::TriPDF > m_centpdf;        //!< Central trivariate PDFs
     120                 :            :     //! Names of and tables to sample and output to statistics file
     121                 :            :     std::pair< std::vector< std::string >,
     122                 :            :                std::vector< tk::Table<1> > > m_tables;
     123                 :            :     //! Map used to lookup moments
     124                 :            :     std::map< tk::ctr::Product, tk::real > m_moments;
     125                 :            : 
     126                 :            :     //! Print information at startup
     127                 :            :     void info( const WalkerPrint& print,
     128                 :            :                uint64_t chunksize,
     129                 :            :                std::size_t nchare );
     130                 :            : 
     131                 :            :     //! Compute size of next time step
     132                 :            :     tk::real computedt();
     133                 :            : 
     134                 :            :     //! Print out time integration header
     135                 :            :     void header( const WalkerPrint& print ) const;
     136                 :            : 
     137                 :            :     //! Print out one-liner report on time step
     138                 :            :     void report();
     139                 :            : 
     140                 :            :     //! Output statistics to file
     141                 :            :     void outStat();
     142                 :            : 
     143                 :            :     //! Write univariate PDF to file
     144                 :            :     void writeUniPDF( std::uint64_t it,
     145                 :            :                       tk::real t,
     146                 :            :                       const tk::UniPDF& p,
     147                 :            :                       tk::ctr::Moment m,
     148                 :            :                       std::size_t idx );
     149                 :            : 
     150                 :            :     //! Write bivariate PDF to file
     151                 :            :     void writeBiPDF( std::uint64_t it, tk::real t,
     152                 :            :                      const tk::BiPDF& p,
     153                 :            :                      tk::ctr::Moment m,
     154                 :            :                      std::size_t idx );
     155                 :            : 
     156                 :            :     //! Write trivariate PDF to file
     157                 :            :     void writeTriPDF( std::uint64_t it,
     158                 :            :                       tk::real t,
     159                 :            :                       const tk::TriPDF& p,
     160                 :            :                       tk::ctr::Moment m,
     161                 :            :                       std::size_t idx );
     162                 :            : 
     163                 :            :     //! Output PDFs to file
     164                 :            :     void outPDF();
     165                 :            : 
     166                 :            :     //! Output all requested univariate PDFs to file(s)
     167                 :            :     void outUniPDF( std::uint64_t it, tk::real t );
     168                 :            : 
     169                 :            :     //! Output all requested bivariate PDFs to file(s)
     170                 :            :     void outBiPDF( std::uint64_t it, tk::real t );
     171                 :            : 
     172                 :            :     //! Output all requested trivariate PDFs to file(s)
     173                 :            :     void outTriPDF( std::uint64_t it, tk::real t );
     174                 :            : 
     175                 :            :     //! Evaluate time step, compute new time step size
     176                 :            :     void evaluateTime();
     177                 :            : 
     178                 :            :     //! Create pretty printer specialized to Walker
     179                 :            :     //! \return Pretty printer
     180                 :       1885 :     WalkerPrint printer() const {
     181                 :            :       const auto& def =
     182                 :            :         g_inputdeck_defaults.get< tag::cmd, tag::io, tag::screen >();
     183                 :       1885 :       auto nrestart = g_inputdeck.get< tag::cmd, tag::io, tag::nrestart >();
     184                 :            :       return WalkerPrint(
     185                 :       1885 :         g_inputdeck.get< tag::cmd >().logname( def, nrestart ),
     186                 :       1885 :         g_inputdeck.get< tag::cmd, tag::verbose >() ? std::cout : std::clog,
     187         [ -  + ]:       3770 :         std::ios_base::app );
     188                 :            :     }
     189                 :            : 
     190                 :            :     //! Normal finish of time stepping
     191                 :            :     void finish();
     192                 :            : };
     193                 :            : 
     194                 :            : } // walker::
     195                 :            : 
     196                 :            : #endif // Distributor_h