doxygen/present__energy_8h_source.html

// -*-c++-*-

#ifndef STORMM_PRESENT_ENERGY_H

#define STORMM_PRESENT_ENERGY_H


#include <fstream>

#include <string>

#include <vector>

#include "copyright.h"

#include "Namelists/nml_files.h"

#include "Namelists/nml_report.h"

#include "Namelists/user_settings.h"

#include "Potential/energy_enumerators.h"

#include "Potential/scorecard.h"

#include "Synthesis/synthesis_cache_map.h"

#include "Synthesis/synthesis_enumerators.h"

#include "report_table.h"


namespace stormm {

namespace review {


using energy::ScoreCard;

using energy::EnergySample;

using energy::StateVariable;

using namelist::FilesControls;

using namelist::ReportControls;

using namelist::UserSettings;

using synthesis::SynthesisCacheMap;

using synthesis::SystemGrouping;


std::vector<StateVariable> assessEnergyDetails(const ScoreCard &nrg,

                                               const SynthesisCacheMap &scmap,

                                               const std::vector<StateVariable> &quantities = {});


std::vector<ReportTable> tabulateAverageEnergy(const ScoreCard &nrg, EnergySample measure,

                                               const std::string &varname,

                                               const SynthesisCacheMap &scmap,

                                               const std::vector<StateVariable> &quantities = {},

                                               const ReportControls &repcon = ReportControls());


ReportTable groupSystemDesignations(const SynthesisCacheMap &scmap,

                                    const SystemGrouping organization, std::string *shortcut_key,

                                    const ReportControls &repcon);


ReportTable groupEnergyAccumulation(const ScoreCard &nrg, const EnergySample measure,

                                    const int* system_indices, const int* group_bounds,

                                    const int group_count, const StateVariable quantity,

                                    const std::string &varname, const ReportControls &repcon);


std::vector<ReportTable> tabulateGroupedEnergy(const ScoreCard &nrg, SystemGrouping organization,

                                               EnergySample measure, const std::string &varname,

                                               std::string *shortcut_key,

                                               const SynthesisCacheMap &scmap,

                                               const std::vector<StateVariable> &quantities = {},

                                               const ReportControls &repcon = ReportControls());


ReportTable allSystemDesignations(std::string *shortcut_key, const SynthesisCacheMap &scmap,

                                  const ReportControls &repcon = ReportControls());


std::vector<ReportTable> tabulateFullEnergy(const ScoreCard &nrg, EnergySample measure,

                                            const std::string &varname, std::string *shortcut_key,

                                            std::string *post_script,

                                            const SynthesisCacheMap &scmap,

                                            const std::vector<StateVariable> &quantities,

                                            const ReportControls &repcon,

                                            const std::vector<bool> &report_mask);


std::vector<ReportTable> tabulateFullEnergy(const ScoreCard &nrg, EnergySample measure,

                                            const std::string &varname, std::string *shortcut_key,

                                            std::string *post_script,

                                            const SynthesisCacheMap &scmap,

                                            const std::vector<StateVariable> &quantities,

                                            const ReportControls &repcon,

                                            const std::vector<int> &report_mask);


std::vector<ReportTable> tabulateFullEnergy(const ScoreCard &nrg, EnergySample measure,

                                            const std::string &varname, std::string *shortcut_key,

                                            std::string *post_script,

                                            const SynthesisCacheMap &scmap,

                                            const std::vector<StateVariable> &quantities = {},

                                            const ReportControls &repcon = ReportControls());


std::vector<ReportTable> tabulateOutlierEnergy(const ScoreCard &nrg, EnergySample measure,

                                               std::string *shortcut_key, std::string *post_script,

                                               const SynthesisCacheMap &scmap,

                                               SystemGrouping organization,

                                               const std::vector<StateVariable> &quantities = {},

                                               const ReportControls &repcon = ReportControls());


void createDiagnosticReport(const ScoreCard &nrg, const SynthesisCacheMap &scmap,

                            const UserSettings &ui);


} // namespace review

} // namespace stormm


#endif


stormm::energy::ScoreCard
Track the energy components of a collection of systems in an HPC-capable array. This object uses the ...
Definition scorecard.h:101

stormm::namelist::ReportControls
Collect output directives relating to the diagnostics file. While the output frequency is controlled ...
Definition nml_report.h:46

stormm::review::ReportTable
Tables in output file sections work differently than tables dumped to the terminal window....
Definition report_table.h:24

stormm::synthesis::SynthesisCacheMap
Encode a map between the systems of a snythesis and those of a SystemCache. The synthesis is expected...
Definition synthesis_cache_map.h:70

stormm::namelist::UserSettings
Object to hold general user input data, including file names or regular expressions for topology and ...
Definition user_settings.h:55