G4PlotManager Class Reference

#include <G4PlotManager.hh>

Public Member Functions
G4bool	CloseFile ()
	G4PlotManager ()=delete
	G4PlotManager (const G4AnalysisManagerState &state)
	G4PlotManager (const G4PlotManager &rhs)=delete
G4bool	OpenFile (const G4String &fileName)
G4PlotManager &	operator= (const G4PlotManager &rhs)=delete
template<typename HT >
G4bool	PlotAndWrite (const std::vector< HT * > &htVector, const std::vector< G4HnInformation * > &hnVector)
	~G4PlotManager ()=default

Private Member Functions
G4int	GetNofPlotsPerPage () const
G4bool	WritePage ()

Private Attributes
G4String	fFileName
G4PlotParameters	fPlotParameters
const G4AnalysisManagerState &	fState
std::unique_ptr< tools::viewplot >	fViewer

Static Private Attributes
static constexpr std::string_view	fkClass { "G4PlotManager" }

Detailed Description

Definition at line 44 of file G4PlotManager.hh.

Constructor & Destructor Documentation

G4PlotManager() [1/3]

G4PlotManager::G4PlotManager ( const G4AnalysisManagerState &  state )

explicit

Definition at line 153 of file G4PlotManager.cc.

 : fState(state)
{
#if defined(TOOLS_USE_FREETYPE)
  fState.Message(kVL1,  "... using high resolution with Freetype fonts", "");
  //Have vertical A4 :
  // unsigned int ww = 2000; //to have better antialising on freetype fonts.
  // float A4 = 29.7f/21.0f;
  // unsigned int wh = (unsigned int)(float(ww)*A4*0.80);
  static tools::sg::text_freetype ttf;
  ttf.add_embedded_font(tools::sg::font_lato_regular_ttf(),tools::font::lato_regular_ttf);
  ttf.add_embedded_font(tools::sg::font_roboto_bold_ttf(),tools::font::roboto_bold_ttf);
  fViewer = std::make_unique<tools::viewplot>(G4cout, ttf,
                                    fPlotParameters.GetColumns(),
                                    fPlotParameters.GetRows(),
                                    fPlotParameters.GetWidth(),
                                    fPlotParameters.GetHeight());
  fViewer->plots().view_border = false;
  load_embeded_styles(fViewer->styles());
  fViewer->styles().add_colormap("default",tools::sg::style_default_colormap());
  fViewer->styles().add_colormap("ROOT",tools::sg::style_ROOT_colormap());
#else
  // cretae a viewer with default parameters
  fState.Message(kVL1,  "... using low resolution with Hershey fonts", "");
  fViewer = std::make_unique<tools::viewplot>(G4cout,
                                    fPlotParameters.GetColumns(),
                                    fPlotParameters.GetRows(),
                                    fPlotParameters.GetWidth(),
                                    fPlotParameters.GetHeight());
  fViewer->plots().view_border = false;
#endif
}

References fPlotParameters, fState, fViewer, G4cout, G4PlotParameters::GetColumns(), G4PlotParameters::GetHeight(), G4PlotParameters::GetRows(), G4PlotParameters::GetWidth(), G4Analysis::kVL1, and G4AnalysisManagerState::Message().

~G4PlotManager()

G4PlotManager::~G4PlotManager ( )

default

G4PlotManager() [2/3]

G4PlotManager::G4PlotManager ( )

delete

G4PlotManager() [3/3]

G4PlotManager::G4PlotManager ( const G4PlotManager &  rhs )

delete

Member Function Documentation

CloseFile()

G4bool G4PlotManager::CloseFile

(

)

Definition at line 241 of file G4PlotManager.cc.

{
  fState.Message(kVL4, "close", "plot file", fFileName);
 
  G4bool result = fViewer->close_file();
  if ( ! result ) {
    Warn("Cannot close the plot file", fkClass, "CloseFile");
  }
 
  fState.Message(kVL1, "close", "plot file", fFileName);
 
  return result;
}

References fFileName, fkClass, fState, fViewer, G4Analysis::kVL1, G4Analysis::kVL4, G4AnalysisManagerState::Message(), and G4Analysis::Warn().

GetNofPlotsPerPage()

G4int G4PlotManager::GetNofPlotsPerPage ( ) const

inlineprivate

Definition at line 81 of file G4PlotManager.hh.

{ return fPlotParameters.GetColumns()*fPlotParameters.GetRows(); }

References fPlotParameters, G4PlotParameters::GetColumns(), and G4PlotParameters::GetRows().

Referenced by PlotAndWrite().

OpenFile()

G4bool G4PlotManager::OpenFile

(

const G4String &

fileName

)

Definition at line 223 of file G4PlotManager.cc.

{
  fState.Message(kVL4, "open", "plot file", fileName);
 
  // Keep filename for logging
  fFileName = fileName;
 
  G4bool result = fViewer->open_file(fileName);
  if ( ! result ) {
    Warn("Cannot open plot file " + fileName, fkClass, "OpenFile");
  }
 
  fState.Message(kVL1, "open", "plot file", fileName);
 
  return result;
}

References fFileName, fkClass, fState, fViewer, G4Analysis::kVL1, G4Analysis::kVL4, G4AnalysisManagerState::Message(), and G4Analysis::Warn().

operator=()

G4PlotManager & G4PlotManager::operator= ( const G4PlotManager &  rhs )

delete

PlotAndWrite()

template<typename HT >

G4bool G4PlotManager::PlotAndWrite ( const std::vector< HT * > &  htVector, const std::vector< G4HnInformation * > &  hnVector  )

inline

Definition at line 87 of file G4PlotManager.hh.

{
  if ( ! htVector.size() ) return true;
 
  fViewer->plots().init_sg();
    //it will recreate the sg::plotters and then reset the styles on new ones.
  fViewer->set_cols_rows(fPlotParameters.GetColumns(), fPlotParameters.GetRows());
  fViewer->plots().set_current_plotter(0);
 
  auto result = true;
  auto isWriteNeeded = false;
 
  for ( G4int i=0; i<G4int(htVector.size()); ++i ) {
    G4HnInformation* info = hnVector[i];
    G4bool plotting = info->GetPlotting();
    G4bool activation = info->GetActivation();
    G4String name = info->GetName();
    // skip plotting if not selected for plotting or
    // if activation is enabled and HT is inactivated
    if ( ( ! plotting ) ||
         ( fState.GetIsActivation() && ( ! activation ) ) ) continue;
 
    HT* ht = htVector[i];
 
    // plot this object
    fViewer->plot(*ht);
    fViewer->set_current_plotter_style(fPlotParameters.GetStyle());
 
    // set color (only blue for the time being)
    tools::sg::plotter& plotter = fViewer->plots().current_plotter();
    // set plot properties (use info object to get these)
    plotter.bins_style(0).color = tools::colorf_blue();
 
    // get axis titles from base_histo (base of all T)
    G4String title;
    if ( ht->annotation(tools::histo::key_axis_x_title(), title) ) {
      plotter.x_axis().title = title;
    }
    if ( ht->annotation(tools::histo::key_axis_y_title(), title) ) {
      plotter.y_axis().title = title;
    }
    if ( ht->annotation(tools::histo::key_axis_z_title(), title) ) {
      plotter.z_axis().title = title;
    }
 
#ifndef TOOLS_USE_FREETYPE
    plotter.set_encoding_none();
#endif
 
    // get log axis parameters from G4HnInformation
    if ( info->GetIsLogAxis(G4Analysis::kX) ) {
      plotter.x_axis().labels_style().encoding = "PAW";
      plotter.x_axis_is_log = true;
    }
    if ( info->GetIsLogAxis(G4Analysis::kY) ) {
      plotter.y_axis().labels_style().encoding = "PAW";
      plotter.y_axis_is_log = true;
    }
    if ( info->GetIsLogAxis(G4Analysis::kZ) ) {
      plotter.z_axis().labels_style().encoding = "PAW";
      plotter.z_axis_is_log = true;
    }
    isWriteNeeded = true;
 
    fState.Message(G4Analysis::kVL3, "plotting", "hd|pd", name);
 
    // write a page if number of plots per page is achieved
    if ( G4int(fViewer->plots().current_index()) == (GetNofPlotsPerPage() - 1) ) {
      result &= WritePage();
      isWriteNeeded = false;
    }
 
    // Prepare for the next plot
    fViewer->plots().next();
  }
 
  // write a page if loop is finished and there are plots to be written
  if ( isWriteNeeded ) {
    result &= WritePage();
  }
 
  // add test of result
  return result;
}

References fPlotParameters, fState, fViewer, G4HnInformation::GetActivation(), G4PlotParameters::GetColumns(), G4AnalysisManagerState::GetIsActivation(), G4HnInformation::GetIsLogAxis(), G4HnInformation::GetName(), GetNofPlotsPerPage(), G4HnInformation::GetPlotting(), G4PlotParameters::GetRows(), G4PlotParameters::GetStyle(), G4Analysis::kVL3, G4Analysis::kX, G4Analysis::kY, G4Analysis::kZ, G4AnalysisManagerState::Message(), G4InuclParticleNames::name(), and WritePage().

WritePage()

G4bool G4PlotManager::WritePage ( )

private

Definition at line 194 of file G4PlotManager.cc.

{
  fState.Message(kVL4, "write a page in", "plot file", fFileName);
 
#if defined(TOOLS_USE_FREETYPE)
  HD_style(fViewer->plots(), 5);
  regions_style(fViewer->plots(), fPlotParameters.GetScale());
#endif
 
  G4bool result = fViewer->write_page();
  if ( ! result ) {
    Warn("Cannot write a page in the plot file " + fFileName,
      fkClass, "WritePage");
  }
 
  // clear viewers plots
  fViewer->plots().init_sg();
    //it will recreate the sg::plotters and then reset the styles on new ones.
 
  fState.Message(kVL3, "write a page in", "plot file", fFileName);
 
  return result;
}

References fFileName, fkClass, fPlotParameters, fState, fViewer, G4PlotParameters::GetScale(), G4Analysis::kVL3, G4Analysis::kVL4, G4AnalysisManagerState::Message(), and G4Analysis::Warn().

Referenced by PlotAndWrite().

Field Documentation

fFileName

G4String G4PlotManager::fFileName

private

Definition at line 75 of file G4PlotManager.hh.

Referenced by CloseFile(), OpenFile(), and WritePage().

fkClass

constexpr std::string_view G4PlotManager::fkClass { "G4PlotManager" }

staticconstexprprivate

Definition at line 69 of file G4PlotManager.hh.

Referenced by CloseFile(), OpenFile(), and WritePage().

fPlotParameters

G4PlotParameters G4PlotManager::fPlotParameters

private

Definition at line 73 of file G4PlotManager.hh.

Referenced by G4PlotManager(), GetNofPlotsPerPage(), PlotAndWrite(), and WritePage().

fState

const G4AnalysisManagerState& G4PlotManager::fState

private

Definition at line 72 of file G4PlotManager.hh.

Referenced by CloseFile(), G4PlotManager(), OpenFile(), PlotAndWrite(), and WritePage().

fViewer

std::unique_ptr<tools::viewplot> G4PlotManager::fViewer

private

Definition at line 74 of file G4PlotManager.hh.

Referenced by CloseFile(), G4PlotManager(), OpenFile(), PlotAndWrite(), and WritePage().

---

The documentation for this class was generated from the following files:

• source/analysis/management/include/G4PlotManager.hh
• source/analysis/management/src/G4PlotManager.cc