G4Analysis Namespace Reference

Typedefs
using	G4ToolsBaseHisto = tools::histo::base_histo< double, unsigned int, unsigned int, double, double >

Functions
G4int	GetNbins (const G4ToolsBaseHisto &baseHisto, G4int dimension)
G4double	GetMin (const G4ToolsBaseHisto &baseHisto, G4int dimension)
G4double	GetMax (const G4ToolsBaseHisto &baseHisto, G4int dimension)
G4double	GetWidth (const G4ToolsBaseHisto &baseHisto, G4int dimension, const G4String &hnType)
G4bool	SetTitle (G4ToolsBaseHisto &baseHisto, const G4String &title)
G4bool	SetAxisTitle (G4ToolsBaseHisto &baseHisto, G4int dimension, const G4String &title)
G4String	GetTitle (const G4ToolsBaseHisto &baseHisto)
G4String	GetAxisTitle (const G4ToolsBaseHisto &baseHisto, G4int dimension, const G4String &hnType)
G4bool	CheckNbins (G4int nbins)
G4bool	CheckMinMax (G4double xmin, G4double xmax, const G4String &fcnName="none", const G4String &binSchemeName="linear")
G4bool	CheckEdges (const std::vector< G4double > &edges)
G4bool	CheckName (const G4String &name, const G4String &objectType)
G4double	GetUnitValue (const G4String &unit)
void	UpdateTitle (G4String &title, const G4String &unitName, const G4String &fcnName)
void	Tokenize (const G4String &line, std::vector< G4String > &tokens)
template<typename T , typename... Args>
std::unique_ptr< T >	make_unique (Args &&...args)
G4AnalysisOutput	GetOutput (const G4String &outputName)
G4String	GetOutputName (G4AnalysisOutput outputType)
G4BinScheme	GetBinScheme (const G4String &binSchemeName)
void	ComputeEdges (G4int nbins, G4double xmin, G4double xmax, G4double unit, G4Fcn fcn, G4BinScheme, std::vector< G4double > &edges)
void	ComputeEdges (const std::vector< G4double > &edges, G4double unit, G4Fcn fcn, std::vector< G4double > &newEdges)
G4Fcn	GetFunction (const G4String &fcnName)

Variables
const G4int	kX = 0
const G4int	kY = 1
const G4int	kZ = 2
const G4int	kInvalidId = -1

Typedef Documentation

using G4Analysis::G4ToolsBaseHisto = typedef tools::histo::base_histo<double, unsigned int, unsigned int, double, double>

Definition at line 43 of file G4BaseHistoUtilities.hh.

Function Documentation

G4bool G4Analysis::CheckEdges

(

const std::vector< G4double > &

edges

)

Definition at line 120 of file G4AnalysisUtilities.cc.

{
  if ( edges.size() <= 1 ) {
    G4ExceptionDescription description;
    description 
      << "    Illegal edges vector (size <= 1)" << G4endl;
      G4Exception("G4VAnalysisManager::CheckEdges",
                  "Analysis_W013", JustWarning, description);
    return false;
  }
  else
    return true;                   

}

Here is the call graph for this function:

Here is the caller graph for this function:

G4bool G4Analysis::CheckMinMax	(	G4double	xmin,
		G4double	xmax,
		const G4String &	fcnName = "none",
		const G4String &	binSchemeName = "linear"
	)

Definition at line 78 of file G4AnalysisUtilities.cc.

{
  auto result = true;
  
  if ( xmax <= xmin ) {
    G4ExceptionDescription description;
    description 
      << "    Illegal values of (xmin >= xmax)" << G4endl;
      G4Exception("G4VAnalysisManager::CheckMinMax",
                  "Analysis_W013", JustWarning, description);
                  
    result = false;
  }
  
  if ( ( fcnName != "none" ) && ( binSchemeName != "linear" ) ) {
    G4ExceptionDescription description;
    description 
      << "    Combining Function and Binning scheme is not supported." 
      << G4endl;
      G4Exception("G4VAnalysisManager::CheckMinMax",
                  "Analysis_W013", JustWarning, description);
                  
    result = false;
  }
  
  if ( ( GetBinScheme(binSchemeName) == G4BinScheme::kLog ||
         fcnName == "log" || fcnName == "log10" ) && ( xmin == 0 ) ) {
    G4ExceptionDescription description;
    description 
      << "    Illegal value of (xmin = 0) with logarithmic function or binning" 
      << G4endl;
      G4Exception("G4VAnalysisManager::CheckMinMax",
                  "Analysis_W013", JustWarning, description);
                  
    result = false;
  }
  
  return result;
}  

Here is the call graph for this function:

Here is the caller graph for this function:

G4bool G4Analysis::CheckName	(	const G4String &	name,
		const G4String &	objectType
	)

Definition at line 136 of file G4AnalysisUtilities.cc.

{
  if ( ! name.size() ) {
    G4ExceptionDescription description;
    description 
      << "    Empty " << objectType << " name is not allowed." << G4endl
      << "    " << objectType << " was not created." << G4endl;
      G4Exception("G4VAnalysisManager::CheckName",
                  "Analysis_W013", JustWarning, description);
    return false;
  }
  else
    return true;                   
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4bool G4Analysis::CheckNbins

(

G4int

nbins

)

Definition at line 62 of file G4AnalysisUtilities.cc.

{
  if ( nbins <= 0 ) {
    G4ExceptionDescription description;
    description 
      << "    Illegal value of number of bins: nbins <= 0" << G4endl;
      G4Exception("G4VAnalysisManager::CheckNbins",
                  "Analysis_W013", JustWarning, description);
    return false;
  }
  else
    return true;                   
}  

Here is the call graph for this function:

Here is the caller graph for this function:

void G4Analysis::ComputeEdges	(	G4int	nbins,
		G4double	xmin,
		G4double	xmax,
		G4double	unit,
		G4Fcn	fcn,
		G4BinScheme	binScheme,
		std::vector< G4double > &	edges
	)

Definition at line 56 of file G4BinScheme.cc.

{
// Compute edges from parameters

  // Apply units
  auto xumin = xmin/unit;
  auto xumax = xmax/unit;

  if ( binScheme == G4BinScheme::kLinear ) {
    auto dx = (fcn(xumax) - fcn(xumin) ) / nbins;
    auto binValue = fcn(xumin);
    while ( G4int(edges.size()) <= nbins ) {  // Loop checking, 23.06.2015, I. Hrivnacova
      edges.push_back(binValue);
      binValue += dx;
    }
  }  
  else if ( binScheme == G4BinScheme::kLog ) {
    // do not apply fcn 
    auto dlog 
      = (std::log10(xumax) - std::log10(xumin))/ nbins;
    auto dx = std::pow(10, dlog);
    auto binValue = xumin;
    while ( G4int(edges.size()) <= nbins ) { // Loop checking, 23.06.2015, I. Hrivnacova
      edges.push_back(binValue);
      binValue *= dx;
    }
  }
  else if ( binScheme == G4BinScheme::kUser ) {  
    // This should never happen, but let's make sure about it
    // by issuing a warning
    G4ExceptionDescription description;
    description 
      << "    User binning scheme setting was ignored." << G4endl
      << "    Linear binning will be applied with given (nbins, xmin, xmax) values";
    G4Exception("G4Analysis::ComputeEdges",
              "Analysis_W013", JustWarning, description);
  }              
}                                          

Here is the call graph for this function:

void G4Analysis::ComputeEdges	(	const std::vector< G4double > &	edges,
		G4double	unit,
		G4Fcn	fcn,
		std::vector< G4double > &	newEdges
	)

Definition at line 98 of file G4BinScheme.cc.

{
// Apply function to defined edges

  for (auto element : edges) {
    newBins.push_back(fcn(element/unit));
  }
}

G4String G4Analysis::GetAxisTitle	(	const G4ToolsBaseHisto &	baseHisto,
		G4int	dimension,
		const G4String &	hnType
	)

Definition at line 110 of file G4BaseHistoUtilities.cc.

{
  G4String title;
  G4bool result = false;
  if ( dimension == kX ) {
    result = baseHisto.annotation(tools::histo::key_axis_x_title(), title);
  }  
  else if ( dimension == kY ) {  
    result = baseHisto.annotation(tools::histo::key_axis_y_title(), title);
  }
  else if ( dimension == kZ ) {  
    result = baseHisto.annotation(tools::histo::key_axis_z_title(), title);
  }

  if ( ! result ) {
    G4String axes("xyz");
    G4String axis = axes(dimension, 1);
    G4String functionName = "Get";
    functionName += hnType;
    functionName += axis;
    functionName += "Title";
    G4ExceptionDescription description;
    description << "    Failed to get " << axis << " axis " << hnType << " title.";
    G4Exception(functionName, "Analysis_W014", JustWarning, description);
    return "";
  }
  
  return title;              
} 

Here is the call graph for this function:

Here is the caller graph for this function:

G4BinScheme G4Analysis::GetBinScheme

(

const G4String &

binSchemeName

)

Definition at line 36 of file G4BinScheme.cc.

{
  G4BinScheme binScheme = G4BinScheme::kLinear;
  if ( binSchemeName != "linear" ) {
    if  ( binSchemeName == "log" )  
      binScheme = G4BinScheme::kLog;
    else {
      // There is no name associated with G4BinScheme::kUser
      G4ExceptionDescription description;
      description 
        << "    \"" << binSchemeName << "\" binning scheme is not supported." << G4endl
        << "    " << "Linear binning will be applied.";
      G4Exception("G4Analysis::GetBinScheme",
                "Analysis_W013", JustWarning, description);
    }              
  }
  return binScheme;            
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4Fcn G4Analysis::GetFunction

(

const G4String &

fcnName

)

Definition at line 36 of file G4Fcn.cc.

{
  G4Fcn fcn = G4FcnIdentity;
   if ( fcnName != "none" ) {
    if      ( fcnName == "log" )  fcn = std::log;
    else if ( fcnName == "log10") fcn = std::log10;
    else if ( fcnName == "exp" )  fcn = std::exp;
    else {
      G4ExceptionDescription description;
      description 
        << "    \"" << fcnName << "\" function is not supported." << G4endl
        << "    " << "No function will be applied to histogram values.";
      G4Exception("G4Analysis::GetFunction",
                "Analysis_W013", JustWarning, description);
    }              
  }
  return fcn;            
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4Analysis::GetMax	(	const G4ToolsBaseHisto &	baseHisto,
		G4int	dimension
	)

Definition at line 53 of file G4BaseHistoUtilities.cc.

{
// Returns max data value

  return baseHisto.get_axis(dimension).upper_edge();
}  

Here is the caller graph for this function:

G4double G4Analysis::GetMin	(	const G4ToolsBaseHisto &	baseHisto,
		G4int	dimension
	)

Definition at line 45 of file G4BaseHistoUtilities.cc.

{
// Returns min data value

  return baseHisto.get_axis(dimension).lower_edge();
}  

Here is the caller graph for this function:

G4int G4Analysis::GetNbins	(	const G4ToolsBaseHisto &	baseHisto,
		G4int	dimension
	)

Definition at line 39 of file G4BaseHistoUtilities.cc.

{
  return baseHisto.get_axis(dimension).bins();
}  

Here is the caller graph for this function:

G4AnalysisOutput G4Analysis::GetOutput

(

const G4String &

outputName

)

Definition at line 192 of file G4AnalysisUtilities.cc.

                                                       {
  if      ( outputName == "csv"  )  { return G4AnalysisOutput::kCsv;  }
  else if ( outputName == "root" )  { return G4AnalysisOutput::kRoot; }
  else if ( outputName == "xml"  )  { return G4AnalysisOutput::kXml;  }
  else if ( outputName == "none" )  { return G4AnalysisOutput::kNone; }
  else {
    G4ExceptionDescription description;
    description 
      << "    \"" << outputName << "\" output type is not supported." << G4endl
      << "    " << "Root type will be used.";
    G4Exception("G4Analysis::GetOutputType",
                "Analysis_W013", JustWarning, description);
    return G4AnalysisOutput::kNone; 
  }
}

Here is the call graph for this function:

G4String G4Analysis::GetOutputName

(

G4AnalysisOutput

outputType

)

Definition at line 209 of file G4AnalysisUtilities.cc.

                                                {
  switch ( output ) {
    case G4AnalysisOutput::kCsv:
      return "csv";
      break;
    case G4AnalysisOutput::kRoot: 
      return "root";
      break;
    case G4AnalysisOutput::kXml:
      return "xml";
      break;
    case G4AnalysisOutput::kNone:
      return "none";
      break;
  }
  // should never reach this line
  G4ExceptionDescription description;
  description
    << "    \"" << static_cast<int>(output) << "\" is not handled." << G4endl
    << "    " << "none type will be used.";
  G4Exception("G4Analysis::GetOutputName",
              "Analysis_W013", JustWarning, description);
  return "none";
}

Here is the call graph for this function:

G4String G4Analysis::GetTitle

(

const G4ToolsBaseHisto &

baseHisto

)

Definition at line 103 of file G4BaseHistoUtilities.cc.

{
  return baseHisto.title();
}  

Here is the caller graph for this function:

G4double G4Analysis::GetUnitValue

(

const G4String &

unit

)

Definition at line 152 of file G4AnalysisUtilities.cc.

{
   G4double value = 1.;
   if ( unit != "none" ) {
     value = G4UnitDefinition::GetValueOf(unit);
     if ( value == 0. ) value = 1.; 
   }  
   return value;
}   

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4Analysis::GetWidth	(	const G4ToolsBaseHisto &	baseHisto,
		G4int	dimension,
		const G4String &	hnType
	)

Definition at line 61 of file G4BaseHistoUtilities.cc.

{
  auto nbins = baseHisto.get_axis(dimension).bins();
  if ( ! nbins ) {
    G4String functionName = "Get";
    functionName += hnType;
    functionName += "Width";
    G4ExceptionDescription description;
    description << "    nbins = 0 (for " << hnType << ").";
    G4Exception(functionName, "Analysis_W014", JustWarning, description);
    return 0.;
  }              
  
  return ( baseHisto.get_axis(dimension).upper_edge() 
           - baseHisto.get_axis(dimension).lower_edge() )/nbins;
}  

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T , typename... Args>

std::unique_ptr<T> G4Analysis::make_unique

(

Args &&...

args

)

Definition at line 84 of file G4AnalysisUtilities.hh.

{
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

G4bool G4Analysis::SetAxisTitle	(	G4ToolsBaseHisto &	baseHisto,
		G4int	dimension,
		const G4String &	title
	)

Definition at line 86 of file G4BaseHistoUtilities.cc.

{
  if ( dimension == kX ) {
    baseHisto.add_annotation(tools::histo::key_axis_x_title(), title);
  }
  else if ( dimension == kY ) {  
    baseHisto.add_annotation(tools::histo::key_axis_y_title(), title);
  }
  else if ( dimension == kZ ) {  
    baseHisto.add_annotation(tools::histo::key_axis_z_title(), title);
  }
  
  return true;
}  

Here is the caller graph for this function:

G4bool G4Analysis::SetTitle	(	G4ToolsBaseHisto &	baseHisto,
		const G4String &	title
	)

Definition at line 80 of file G4BaseHistoUtilities.cc.

{
  return baseHisto.set_title(title);
}  

Here is the caller graph for this function:

void G4Analysis::Tokenize	(	const G4String &	line,
		std::vector< G4String > &	tokens
	)

Definition at line 173 of file G4AnalysisUtilities.cc.

{
  // Define start values
  std::string::size_type begIdx = 0;
  std::string::size_type endIdx = 0; 
  G4String token;
  
  do {
    if ( GetToken(line, token, begIdx, endIdx) ) {
      //G4cout << "got token: '" << token << "'" << G4endl;
      //G4cout << "beg, end: " << begIdx << ", " << endIdx << G4endl;
      tokens.push_back(token);
    }  
    begIdx = endIdx + 1;
  }
  while ( endIdx < line.length() ); // Loop checking, 23.06.2015, I. Hrivnacova
}

Here is the caller graph for this function:

void G4Analysis::UpdateTitle	(	G4String &	title,
		const G4String &	unitName,
		const G4String &	fcnName
	)

Definition at line 163 of file G4AnalysisUtilities.cc.

{
  if ( fcnName != "none" )  { title += " "; title += fcnName; title += "("; }
  if ( unitName != "none" ) { title += " ["; title += unitName; title += "]";}
  if ( fcnName != "none" )  { title += ")"; }
}                                                            

Variable Documentation

const G4int G4Analysis::kInvalidId = -1

Definition at line 62 of file G4AnalysisUtilities.hh.

const G4int G4Analysis::kX = 0

Definition at line 55 of file G4AnalysisUtilities.hh.

const G4int G4Analysis::kY = 1

Definition at line 56 of file G4AnalysisUtilities.hh.

const G4int G4Analysis::kZ = 2

Definition at line 57 of file G4AnalysisUtilities.hh.