G4PlotManager Class Reference

#include <G4PlotManager.hh>

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

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)
  //////////////////////////////////////////////////////////////////////////////
  /// plotting, high resolution with freetype fonts and by using styles : //////
  //////////////////////////////////////////////////////////////////////////////
  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 toolx::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
}

~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;
}

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;
}

operator=()

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

delete

PlotAndWrite()

template<typename HT >

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

inline

Definition at line 86 of file G4PlotManager.hh.

{
  if ( ! hnVector.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 (const auto& [ht, info] : hnVector) {
    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;
 
    // 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;
}

---

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

• G4PlotManager.hh
• G4PlotManager.cc