G4Analysis Namespace Reference

Functions
void	Warn (const G4String &message, const std::string_view inClass, const std::string_view inFunction)
G4double	GetUnitValue (const G4String &unit)
void	Tokenize (const G4String &line, std::vector< G4String > &tokens)
G4AnalysisOutput	GetOutput (const G4String &outputName, G4bool warn=true)
size_t	GetOutputId (const G4String &outputName, G4bool warn=true)
G4String	GetOutputName (G4AnalysisOutput outputType)
template<typename HT >
G4String	GetHnType ()
template<typename HT >
G4bool	IsProfile ()
template<typename T >
std::string	ToString (const T &value)
template<>
std::string	ToString< std::string > (const std::string &value)
G4String	GetBaseName (const G4String &fileName)
G4String	GetExtension (const G4String &fileName, const G4String &defaultExtension="")
G4String	GetHnFileName (const G4String &fileName, const G4String &fileType, const G4String &hnType, const G4String &hnName)
G4String	GetHnFileName (const G4String &fileName, const G4String &fileType, G4int cycle=0)
G4String	GetNtupleFileName (const G4String &fileName, const G4String &fileType, const G4String &ntupleName, G4int cycle=0)
G4String	GetNtupleFileName (const G4String &fileName, const G4String &fileType, G4int ntupleFileNumber, G4int cycle=0)
G4String	GetTnFileName (const G4String &fileName, const G4String &fileType, G4int cycle=0)
G4String	GetPlotFileName (const G4String &fileName)
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)
void	Update (G4double &value, const G4HnDimensionInformation &hnInfo)
void	UpdateValues (G4HnDimension &bins, const G4HnDimensionInformation &hnInfo)
void	Update (G4HnDimension &bins, const G4HnDimensionInformation &hnInfo)
void	UpdateTitle (G4String &title, const G4HnDimensionInformation &hnInfo)
G4bool	CheckMinMax (G4double min, G4double max)
G4bool	CheckDimension (unsigned int idim, const G4HnDimension &dimension, const G4HnDimensionInformation &info)
template<unsigned int DIM>
G4bool	CheckDimensions (const std::array< G4HnDimension, DIM > &bins, const std::array< G4HnDimensionInformation, DIM > &hnInfo, G4bool isProfile=false)

Variables
constexpr G4int	kX { 0 }
constexpr G4int	kY { 1 }
constexpr G4int	kZ { 2 }
constexpr G4int	kInvalidId { -1 }
constexpr G4int	kVL0 { 0 }
constexpr G4int	kVL1 { 1 }
constexpr G4int	kVL2 { 2 }
constexpr G4int	kVL3 { 3 }
constexpr G4int	kVL4 { 4 }
constexpr unsigned int	kDim1 { 1 }
constexpr unsigned int	kDim2 { 2 }
constexpr unsigned int	kDim3 { 3 }
constexpr unsigned int	kMaxDim { kDim3 }
constexpr unsigned int	kDefaultBasketSize { 32000 }
constexpr unsigned int	kDefaultBasketEntries {4000 }
constexpr std::string_view	kNamespaceName { "G4Analysis" }

Function Documentation

CheckDimension()

G4bool G4Analysis::CheckDimension	(	unsigned int	idim,
		const G4HnDimension &	dimension,
		const G4HnDimensionInformation &	info )

Definition at line 155 of file G4HnInformation.cc.

{
  auto result = true;
  G4String xyz {"xyz"};
 
  // Check nbins
  if ( (dimension.fNBins <= 0) && (info.fBinScheme != G4BinScheme::kUser) ) {
    Warn("Illegal value of number of " + xyz.substr(idim,1) + " bins: nbins <= 0.",
      kNamespaceName, "CheckDimension");
    result = false;
  }
 
  // Check min/max
  if ( (dimension.fMaxValue <= dimension.fMinValue) &&
       (info.fBinScheme != G4BinScheme::kUser) ) {
    Warn("Illegal value of " + xyz.substr(idim,1) + " (min >= max)",
      kNamespaceName, "CheckDimension");
    result = false;
  }
 
  // Check edges
  if (info.fBinScheme == G4BinScheme::kUser) {
    if ( dimension.fEdges.empty() ) {
      Warn(xyz.substr(idim,1) + " edges vector is empty.",
        kNamespaceName, "CheckDimension");
      result = false;
    }
    // the edges values must be defined in increasing order
    for (size_t i = 1; i < dimension.fEdges.size(); ++i){
      if (dimension.fEdges[i-1] >= dimension.fEdges[i]) {
        Warn(xyz.substr(idim,1) +
          " edges vector values must be defined in increasing order.",
          kNamespaceName, "CheckDimension");
        result = false;
      }
    }
  }
 
  // Check function
  if ( ( info.fFcnName != "none" ) && ( info.fBinScheme != G4BinScheme::kLinear ) ) {
    Warn("Combining  " + xyz.substr(idim,1) + " Function and Binning scheme is not supported.",
      kNamespaceName, "CheckDimension");
    result = false;
  }
 
  // Check minValue if log binning or log function
  if ( ( info.fBinScheme == G4BinScheme::kLog ||
         info.fFcnName == "log" || info.fFcnName == "log10" ) && ( dimension.fMinValue == 0 ) ) {
    Warn("Illegal value of " + xyz.substr(idim,1) + " (min = 0) with logarithmic function or binning",
      kNamespaceName, "CheckDimension");
    result = false;
  }
 
  return result;
}

Referenced by CheckDimensions().

CheckDimensions()

template<unsigned int DIM>

G4bool G4Analysis::CheckDimensions ( const std::array< G4HnDimension, DIM > & bins, const std::array< G4HnDimensionInformation, DIM > & hnInfo, G4bool isProfile = false )

inline

Definition at line 246 of file G4HnInformation.hh.

{
  G4bool result = true;
 
  // Check bins parameters
  // (the last dimension has special meaninh for profiles)
  auto dimToCheck = (isProfile) ? DIM -1 : DIM ;
  for (unsigned int idim = 0; idim < dimToCheck; ++idim) {
    result &= CheckDimension(idim, bins[idim], hnInfo[idim]);
  }
 
  // Check profile min/max value
  if (isProfile) {
    result &= CheckMinMax(bins[DIM-1].fMinValue, bins[DIM-1].fMaxValue);
  }
 
  return result;
}

CheckMinMax()

G4bool G4Analysis::CheckMinMax	(	G4double	min,
		G4double	max )

Definition at line 139 of file G4HnInformation.cc.

{
  auto result = true;
 
  // Do not check default values
  if ( minValue == 0. && maxValue == 0. ) return result;
 
  if ( maxValue <= minValue ) {
    Warn("Illegal value of (minValue >= maxMaxValue)", kNamespaceName, "CheckMinMax");
    result = false;
  }
 
  return result;
}

Referenced by CheckDimensions().

ComputeEdges() [1/2]

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

Definition at line 105 of file G4BinScheme.cc.

{
// Apply function & unit to defined edges
 
  if (unit == 0.) {
    // Should never happen
    Warn("Illegal unit value (0), 1. will be used instead",
      kNamespaceName, "ComputeEdges");
    unit = 1.;
  }
 
  for (auto element : edges) {
    newBins.push_back(fcn(element/unit));
  }
}

ComputeEdges() [2/2]

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

Definition at line 50 of file G4BinScheme.cc.

{
// Compute edges from parameters
 
  if ( binScheme == G4BinScheme::kUser ) {
    // This call should never happen for user bin scheme
    Warn("There is no need to compute edges for G4BinScheme::kUser\n"
         "Call is ignored.", kNamespaceName, "GetBinScheme");
    return;
  }
 
  if (unit == 0.) {
    // Should never happen
    Warn("Illegal unit value (0), 1. will be used instead",
      kNamespaceName, "ComputeEdges");
    unit = 1.;
  }
 
  if (nbins == 0) {
    // Should never happen
    Warn("Illegal number of nbins value (0), call will be ignored",
      kNamespaceName, "ComputeEdges");
    return;
  }
 
  // 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;
    }
    return;
  }
 
  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;
    }
    return;
  }
}

Referenced by Update().

GetBaseName()

G4String G4Analysis::GetBaseName

(

const G4String &

fileName

)

Definition at line 147 of file G4AnalysisUtilities.cc.

{
// Get file base name (without dot)
 
  G4fs::path filePath(fileName.data());
  if ( filePath.has_parent_path()) {
    return  filePath.parent_path().string() + "/" + filePath.stem().string();
  }
 
  return filePath.stem().string();
}

Referenced by G4CsvFileManager::CreateNtupleFile(), G4BaseFileManager::GetFullFileName(), GetHnFileName(), GetHnFileName(), GetNtupleFileName(), GetNtupleFileName(), GetPlotFileName(), GetTnFileName(), G4VFileManager::SetFileName(), and G4NtupleBookingManager::SetFileType().

GetBinScheme()

G4BinScheme G4Analysis::GetBinScheme

(

const G4String &

binSchemeName

)

Definition at line 36 of file G4BinScheme.cc.

{
  if (binSchemeName == "linear") return G4BinScheme::kLinear;
  if (binSchemeName == "log")    return G4BinScheme::kLog;
  if (binSchemeName == "user")   return G4BinScheme::kUser;
 
  // No other name is supported
  Warn("\"" + binSchemeName + "\" binning scheme is not supported.\n"
       "Linear binning will be applied.", kNamespaceName, "GetBinScheme");
 
  return G4BinScheme::kLinear;
}

GetExtension()

G4String G4Analysis::GetExtension	(	const G4String &	fileName,
		const G4String &	defaultExtension = "" )

Definition at line 160 of file G4AnalysisUtilities.cc.

{
// Get file base extension (without dot)
// If fileName is provided without extension, return defaultExtension
 
  G4fs::path filePath(fileName.data());
  if ( filePath.has_extension() ) {
    auto extension = filePath.extension().string();
    // remove "."
    return extension.substr(1, extension.length());
  }
 
  return defaultExtension;
}

Referenced by G4CsvFileManager::CreateNtupleFile(), G4GenericFileManager::GetFileManager(), G4VAnalysisManager::GetFileManager(), G4BaseFileManager::GetFullFileName(), GetHnFileName(), GetHnFileName(), GetNtupleFileName(), GetNtupleFileName(), GetTnFileName(), G4GenericAnalysisManager::OpenFileImpl(), G4NtupleBookingManager::SetFileName(), G4VFileManager::SetFileName(), and G4NtupleBookingManager::SetFileType().

GetFunction()

G4Fcn G4Analysis::GetFunction

(

const G4String &

fcnName

)

Definition at line 36 of file G4Fcn.cc.

{
  // clang-format off
  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 {
      Warn(
        "\"" + fcnName + "\" function is not supported.\n" +
        "No function will be applied to histogram values.",
        kNamespaceName, "GetFunction");
    }
  }
  return fcn;
  // clang-format on
}

GetHnFileName() [1/2]

G4String G4Analysis::GetHnFileName	(	const G4String &	fileName,
		const G4String &	fileType,
		const G4String &	hnType,
		const G4String &	hnName )

Definition at line 177 of file G4AnalysisUtilities.cc.

{
// Compose and return the histogram or profile specific file name:
// - add _hn_hnName suffix to the file base name
// - add _vN  suffix if cycle > 0
// - add file extension if not present
 
  auto name = GetBaseName(fileName);
 
  // Add _hnType_hnName
  name.append("_");
  name.append(hnType);
  name.append("_");
  name.append(hnName);
 
  // Add file extension
  auto extension = GetExtension(fileName, fileType);
  if (extension.size() != 0u) {
    name.append(".");
    name.append(extension);
  }
 
  return name;
}

Referenced by G4BaseFileManager::GetHnFileName(), and G4CsvFileManager::GetNtupleFileName().

GetHnFileName() [2/2]

G4String G4Analysis::GetHnFileName	(	const G4String &	fileName,
		const G4String &	fileType,
		G4int	cycle = 0 )

Definition at line 207 of file G4AnalysisUtilities.cc.

{
// Update Hn file name:
// - add _vN  suffix to the base namer if cycle > 0
 
  auto name = GetBaseName(fileName);
 
  // Add cycle number
  if (cycle > 0) {
    name.append("_v");
    name.append(std::to_string(cycle));
  }
 
  // Add file extension
  auto extension = GetExtension(fileName, fileType);
  if (extension.size() != 0u) {
    name.append(".");
    name.append(extension);
  }
 
  return name;
}

GetHnType()

template<typename HT >

G4String G4Analysis::GetHnType

(

)

Definition at line 90 of file G4AnalysisUtilities.hh.

{
  // tools::histo::h1d etc.
  G4String hnTypeLong = HT::s_class();
 
  // tools::histo::h1d -> h1 etc.
  return hnTypeLong.substr(14, 2);
}

GetNtupleFileName() [1/2]

G4String G4Analysis::GetNtupleFileName	(	const G4String &	fileName,
		const G4String &	fileType,
		const G4String &	ntupleName,
		G4int	cycle = 0 )

Definition at line 234 of file G4AnalysisUtilities.cc.

{
// Compose and return the ntuple specific file name:
// - add _nt_ntupleName suffix to the file base name
// - add _vN  suffix if cycle > 0
// - add _tN suffix if called on thread worker
// - add file extension if not present
 
  auto name = GetBaseName(fileName);
 
  // Add ntupleName
  name.append("_nt_");
  name.append(ntupleName);
 
  // Add cycle number
  if (cycle > 0) {
    name.append("_v");
    name.append(std::to_string(cycle));
  }
 
  // Add thread Id to a file name if MT processing
  if ( ! G4Threading::IsMasterThread() ) {
    std::ostringstream os;
    os << G4Threading::G4GetThreadId();
    name.append("_t");
    name.append(os.str());
  }
 
  // Add file extension
  auto extension = GetExtension(fileName, fileType);
  if (extension.size() != 0u) {
    name.append(".");
    name.append(extension);
  }
 
  return name;
}

Referenced by G4BaseFileManager::GetNtupleFileName(), and G4BaseFileManager::GetNtupleFileName().

GetNtupleFileName() [2/2]

G4String G4Analysis::GetNtupleFileName	(	const G4String &	fileName,
		const G4String &	fileType,
		G4int	ntupleFileNumber,
		G4int	cycle = 0 )

Definition at line 277 of file G4AnalysisUtilities.cc.

{
// Compose and return the ntuple specific file name:
// - add _mFN suffix to the file base name where FN = ntupleFileNumber
// - add _vN  suffix if cycle > 0
// - add file extension if not present
 
  auto name = GetBaseName(fileName);
 
  // Add _M followed by ntupleFileNumber
  std::ostringstream os;
  os << ntupleFileNumber;
  name.append("_m");
  name.append(os.str());
 
  // Add cycle number
  if (cycle > 0) {
    name.append("_v");
    name.append(std::to_string(cycle));
  }
 
  // Add file extension
  auto extension = GetExtension(fileName, fileType);
  if (extension.size() != 0u) {
    name.append(".");
    name.append(extension);
  }
 
  return name;
}

GetOutput()

G4AnalysisOutput G4Analysis::GetOutput	(	const G4String &	outputName,
		G4bool	warn = true )

Definition at line 105 of file G4AnalysisUtilities.cc.

{
  if (outputName == "csv")  return G4AnalysisOutput::kCsv;
  if (outputName == "hdf5") return G4AnalysisOutput::kHdf5;
  if (outputName == "root") return G4AnalysisOutput::kRoot;
  if (outputName == "xml")  return G4AnalysisOutput::kXml;
  if (outputName == "none") return G4AnalysisOutput::kNone;
 
  if (warn) {
    Warn("\"" + outputName + "\" output type is not supported.", kNamespaceName, "GetOutput");
  }
  return G4AnalysisOutput::kNone;
}

Referenced by G4GenericFileManager::GetFileManager(), G4GenericFileManager::SetDefaultFileType(), and G4NtupleBookingManager::SetFileName().

GetOutputId()

size_t G4Analysis::GetOutputId	(	const G4String &	outputName,
		G4bool	warn = true )

GetOutputName()

G4String G4Analysis::GetOutputName

(

G4AnalysisOutput

outputType

)

Definition at line 120 of file G4AnalysisUtilities.cc.

{
  switch ( output ) {
    case G4AnalysisOutput::kCsv:
      return "csv";
      break;
    case G4AnalysisOutput::kHdf5:
      return "hdf5";
      break;
    case G4AnalysisOutput::kRoot:
      return "root";
      break;
    case G4AnalysisOutput::kXml:
      return "xml";
      break;
    case G4AnalysisOutput::kNone:
      return "none";
      break;
  }
  // should never reach this line
  Warn("\"" + to_string(static_cast<int>(output)) +
       "\" output type is not supported.",
       kNamespaceName, "CheckOutputName");
  return "none";
}

Referenced by G4GenericFileManager::CreateNtupleFileManager().

GetPlotFileName()

G4String G4Analysis::GetPlotFileName

(

const G4String &

fileName

)

Definition at line 349 of file G4AnalysisUtilities.cc.

{
// Generate plot file name for an output file name
 
  auto name = GetBaseName(fileName);
 
  // Add .ps extension
  name.append(".ps");
 
  return name;
}

Referenced by G4BaseFileManager::GetPlotFileName().

GetTnFileName()

G4String G4Analysis::GetTnFileName	(	const G4String &	fileName,
		const G4String &	fileType,
		G4int	cycle = 0 )

Definition at line 313 of file G4AnalysisUtilities.cc.

{
// Update file base name with the thread suffix:
// - add _tN suffix if called on thread worker
// - add file extension if not present
 
  auto name = GetBaseName(fileName);
 
  // Add cycle number
  if (cycle > 0) {
    name.append("_v");
    name.append(std::to_string(cycle));
  }
 
  // Add thread Id to a file name if MT processing
  if ( !  G4Threading::IsMasterThread() ) {
    std::ostringstream os;
    os << G4Threading::G4GetThreadId();
    name.append("_t");
    name.append(os.str());
  }
 
  // Add file extension
  auto extension = GetExtension(fileName, fileType);
  if (extension.size() != 0u) {
    name.append(".");
    name.append(extension);
  }
 
  return name;
}

GetUnitValue()

G4double G4Analysis::GetUnitValue

(

const G4String &

unit

)

Definition at line 75 of file G4AnalysisUtilities.cc.

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

IsProfile()

template<typename HT >

G4bool G4Analysis::IsProfile

(

)

Definition at line 100 of file G4AnalysisUtilities.hh.

{
  // tools::histo::h1d etc.
  G4String hnTypeLong = HT::s_class();
 
  // tools::histo::h1d -> h1 etc.
  return hnTypeLong[14] == 'p';
}

Tokenize()

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

Definition at line 86 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
}

Referenced by G4HnMessenger::SetNewValue(), G4NtupleMessenger::SetNewValue(), and G4PlotMessenger::SetNewValue().

ToString()

template<typename T >

std::string G4Analysis::ToString ( const T & value )

inline

Definition at line 112 of file G4AnalysisUtilities.hh.

{ return std::to_string(value); }

ToString< std::string >()

template<>

std::string G4Analysis::ToString< std::string > ( const std::string & value )

inline

Definition at line 117 of file G4AnalysisUtilities.hh.

{ return value; }

Update() [1/2]

void G4Analysis::Update	(	G4double &	value,
		const G4HnDimensionInformation &	hnInfo )

Definition at line 58 of file G4HnInformation.cc.

{
// Apply hnInfo to a value
 
  auto unit = hnInfo.fUnit;
  auto fcn = hnInfo.fFcn;
 
  if (unit == 0.) {
    // Should never happen
    Warn("Illegal unit value (0), 1. will be used instead",
      kNamespaceName, "UpdateBins");
    unit = 1.;
  }
  value = fcn(value/unit);
}

Update() [2/2]

void G4Analysis::Update	(	G4HnDimension &	bins,
		const G4HnDimensionInformation &	hnInfo )

Definition at line 95 of file G4HnInformation.cc.

{
// Apply hnInfo to bins, compute edges
 
  auto unit = hnInfo.fUnit;
  auto fcn = hnInfo.fFcn;
  auto binScheme = hnInfo.fBinScheme;
 
  if (binScheme == G4BinScheme::kLinear) {
    // Compute edges, as they may be needed in the context of 2D or 3D histograms
    // with log binning in other dimension
    G4Analysis::ComputeEdges(
      bins.fNBins, bins.fMinValue, bins.fMaxValue, unit, fcn, binScheme, bins.fEdges);
 
    // Update min/max Values
    UpdateValues(bins, hnInfo);
 
    return;
  }
 
  if (binScheme == G4BinScheme::kLog) {
    // Logarithmic bin scheme
    // compute edges from parameters
    G4Analysis::ComputeEdges(
      bins.fNBins, bins.fMinValue, bins.fMaxValue, unit, fcn, binScheme, bins.fEdges);
  }
 
  if (binScheme == G4BinScheme::kUser) {
    std::vector<G4double> edges = bins.fEdges;
    bins.fEdges.clear();
    G4Analysis::ComputeEdges(edges, unit, fcn, bins.fEdges);
  }
}

UpdateTitle()

void G4Analysis::UpdateTitle	(	G4String &	title,
		const G4HnDimensionInformation &	hnInfo )

Definition at line 131 of file G4HnInformation.cc.

{
  if ( hnInfo.fFcnName != "none" )  { title += " "; title +=  hnInfo.fFcnName; title += "("; }
  if ( hnInfo.fUnitName != "none" ) { title += " ["; title += hnInfo.fUnitName; title += "]";}
  if ( hnInfo.fFcnName != "none" )  { title += ")"; }
}

UpdateValues()

void G4Analysis::UpdateValues	(	G4HnDimension &	bins,
		const G4HnDimensionInformation &	hnInfo )

Definition at line 75 of file G4HnInformation.cc.

{
// Apply hnInfo to bins min and max value
 
  auto unit = hnInfo.fUnit;
  auto fcn = hnInfo.fFcn;
 
  if (unit == 0.) {
    // Should never happen
    Warn("Illegal unit value (0), 1. will be used instead",
      kNamespaceName, "UpdateBins");
    unit = 1.;
  }
  // Update min/max values
  bins.fMinValue = fcn(bins.fMinValue/unit);
  bins.fMaxValue = fcn(bins.fMaxValue/unit);
}

Referenced by Update().

Warn()

void G4Analysis::Warn	(	const G4String &	message,
		const std::string_view	inClass,
		const std::string_view	inFunction )

Definition at line 66 of file G4AnalysisUtilities.cc.

{
  auto source = std::string(inClass) + "::" + std::string(inFunction);
  G4Exception(source.data(), "Analysis_W001", JustWarning, message);
}

Referenced by CheckDimension(), CheckMinMax(), G4PlotManager::CloseFile(), G4ToolsAnalysisManager::CloseFileImpl(), ComputeEdges(), ComputeEdges(), G4CsvFileManager::CreateFileImpl(), G4Hdf5FileManager::CreateFileImpl(), G4RootFileManager::CreateFileImpl(), G4XmlFileManager::CreateFileImpl(), G4RootMainNtupleManager::CreateNtuple(), G4CsvFileManager::CreateNtupleFile(), G4GenericFileManager::CreateNtupleFileManager(), G4RootMainNtupleManager::Delete(), GetBinScheme(), G4GenericFileManager::GetFileManager(), G4VAnalysisManager::GetFileManager(), GetFunction(), G4HnManager::GetHnInformation(), G4VAnalysisReader::GetNtuple(), GetOutput(), GetOutputName(), G4GenericFileManager::OpenFile(), G4Hdf5FileManager::OpenFile(), G4PlotManager::OpenFile(), G4RootFileManager::OpenFile(), G4VAnalysisManager::OpenFile(), G4XmlFileManager::OpenFile(), G4CsvRFileManager::OpenRFile(), G4RootRFileManager::OpenRFile(), G4XmlRFileManager::OpenRFile(), G4VAnalysisReader::ReadH1(), G4VAnalysisReader::ReadH2(), G4VAnalysisReader::ReadH3(), G4VAnalysisReader::ReadP1(), G4VAnalysisReader::ReadP2(), G4GenericFileManager::SetDefaultFileType(), G4VAnalysisManager::SetDefaultFileTypeImpl(), G4NtupleBookingManager::SetFileName(), G4VFileManager::SetFileName(), G4NtupleBookingManager::SetFileType(), G4BaseAnalysisManager::SetFirstId(), G4NtupleBookingManager::SetFirstNtupleColumnId(), G4CsvFileManager::SetHistoDirectoryName(), G4VFileManager::SetHistoDirectoryName(), G4PlotParameters::SetLayout(), G4HnMessenger::SetNewValue(), G4NtupleMessenger::SetNewValue(), G4PlotMessenger::SetNewValue(), G4CsvFileManager::SetNtupleDirectoryName(), G4VFileManager::SetNtupleDirectoryName(), G4RootNtupleFileManager::SetNtupleMerging(), G4PlotParameters::SetStyle(), Update(), UpdateValues(), and G4VAnalysisManager::WriteAscii().

Variable Documentation

kDefaultBasketEntries

unsigned int G4Analysis::kDefaultBasketEntries {4000 }

constexpr

Definition at line 68 of file G4AnalysisUtilities.hh.

{4000 };

kDefaultBasketSize

unsigned int G4Analysis::kDefaultBasketSize { 32000 }

constexpr

Definition at line 67 of file G4AnalysisUtilities.hh.

{ 32000 };

kDim1

unsigned int G4Analysis::kDim1 { 1 }

constexpr

Definition at line 63 of file G4AnalysisUtilities.hh.

{ 1 };

kDim2

unsigned int G4Analysis::kDim2 { 2 }

constexpr

Definition at line 64 of file G4AnalysisUtilities.hh.

{ 2 };

kDim3

unsigned int G4Analysis::kDim3 { 3 }

constexpr

Definition at line 65 of file G4AnalysisUtilities.hh.

{ 3 };

kInvalidId

G4int G4Analysis::kInvalidId { -1 }

constexpr

Definition at line 57 of file G4AnalysisUtilities.hh.

{ -1 };

Referenced by G4Hdf5RFileManager::CloseFiles(), G4NtupleBookingManager::CreateNtuple(), G4RootMainNtupleManager::CreateNtuple(), G4Hdf5FileManager::GetHistoDirectory(), G4VAnalysisReader::GetNtuple(), G4Hdf5FileManager::GetNtupleDirectory(), G4VAnalysisReader::ReadH1(), G4VAnalysisReader::ReadH2(), G4VAnalysisReader::ReadH3(), G4VAnalysisReader::ReadP1(), G4VAnalysisReader::ReadP2(), and G4NtupleMessenger::SetNewValue().

kMaxDim

unsigned int G4Analysis::kMaxDim { kDim3 }

constexpr

Definition at line 66 of file G4AnalysisUtilities.hh.

{ kDim3 };

Referenced by G4HnMessenger::G4HnMessenger(), and G4HnMessenger::SetNewValue().

kNamespaceName

std::string_view G4Analysis::kNamespaceName { "G4Analysis" }

constexpr

Definition at line 69 of file G4AnalysisUtilities.hh.

{ "G4Analysis" };

Referenced by CheckDimension(), CheckMinMax(), ComputeEdges(), ComputeEdges(), GetBinScheme(), GetFunction(), GetOutput(), GetOutputName(), Update(), and UpdateValues().

kVL0

G4int G4Analysis::kVL0 { 0 }

constexpr

Definition at line 58 of file G4AnalysisUtilities.hh.

{ 0 };

kVL1

G4int G4Analysis::kVL1 { 1 }

constexpr

Definition at line 59 of file G4AnalysisUtilities.hh.

{ 1 };

Referenced by G4RootNtupleFileManager::ActionAtOpenFile(), G4VAnalysisManager::Clear(), G4PlotManager::CloseFile(), G4PlotManager::G4PlotManager(), G4GenericFileManager::OpenFile(), G4PlotManager::OpenFile(), G4CsvRFileManager::OpenRFile(), G4RootRFileManager::OpenRFile(), G4XmlRFileManager::OpenRFile(), G4RootNtupleFileManager::SetNtupleRowWise(), and G4VAnalysisManager::WriteAscii().

kVL2

G4int G4Analysis::kVL2 { 2 }

constexpr

Definition at line 60 of file G4AnalysisUtilities.hh.

{ 2 };

Referenced by G4RootNtupleFileManager::ActionAtWrite(), G4NtupleBookingManager::ClearData(), G4RootMainNtupleManager::ClearData(), G4CsvAnalysisReader::CloseFilesImpl(), G4Hdf5AnalysisReader::CloseFilesImpl(), G4RootAnalysisReader::CloseFilesImpl(), G4XmlAnalysisReader::CloseFilesImpl(), G4NtupleBookingManager::CreateNtuple(), G4NtupleBookingManager::Delete(), G4XmlRNtupleManager::SetNtupleDColumn(), G4XmlRNtupleManager::SetNtupleIColumn(), and G4XmlRNtupleManager::SetNtupleSColumn().

kVL3

G4int G4Analysis::kVL3 { 3 }

constexpr

Definition at line 61 of file G4AnalysisUtilities.hh.

{ 3 };

Referenced by G4ToolsAnalysisManager::CloseFileImpl(), G4GenericFileManager::CloseFiles(), G4RootNtupleFileManager::CreateNtupleManager(), G4RootMainNtupleManager::Delete(), G4GenericFileManager::DeleteEmptyFiles(), G4GenericAnalysisManager::OpenFileImpl(), G4GenericFileManager::OpenFiles(), G4PlotManager::PlotAndWrite(), G4ToolsAnalysisManager::ResetImpl(), G4VAnalysisManager::WriteAscii(), G4GenericFileManager::WriteFiles(), G4ToolsAnalysisManager::WriteImpl(), and G4THnToolsManager< DIM, HT >::WriteOnAscii().

kVL4

G4int G4Analysis::kVL4 { 4 }

constexpr

Definition at line 62 of file G4AnalysisUtilities.hh.

{ 4 };

Referenced by G4RootNtupleFileManager::ActionAtOpenFile(), G4RootNtupleFileManager::ActionAtWrite(), G4VAnalysisManager::Clear(), G4PlotManager::CloseFile(), G4ToolsAnalysisManager::CloseFileImpl(), G4GenericFileManager::CloseFiles(), G4CsvAnalysisReader::CloseFilesImpl(), G4Hdf5AnalysisReader::CloseFilesImpl(), G4RootAnalysisReader::CloseFilesImpl(), G4XmlAnalysisReader::CloseFilesImpl(), G4NtupleBookingManager::CreateNtuple(), G4RootNtupleFileManager::CreateNtupleManager(), G4NtupleBookingManager::Delete(), G4RootMainNtupleManager::Delete(), G4GenericFileManager::DeleteEmptyFiles(), G4GenericFileManager::OpenFile(), G4PlotManager::OpenFile(), G4GenericAnalysisManager::OpenFileImpl(), G4GenericFileManager::OpenFiles(), G4CsvRFileManager::OpenRFile(), G4RootRFileManager::OpenRFile(), G4XmlRFileManager::OpenRFile(), G4ToolsAnalysisManager::ResetImpl(), G4XmlRNtupleManager::SetNtupleDColumn(), G4XmlRNtupleManager::SetNtupleFColumn(), G4XmlRNtupleManager::SetNtupleIColumn(), G4XmlRNtupleManager::SetNtupleSColumn(), G4GenericFileManager::WriteFiles(), and G4ToolsAnalysisManager::WriteImpl().

kX

G4int G4Analysis::kX { 0 }

constexpr

Definition at line 54 of file G4AnalysisUtilities.hh.

{ 0 };

Referenced by G4PlotManager::PlotAndWrite().

kY

G4int G4Analysis::kY { 1 }

constexpr

Definition at line 55 of file G4AnalysisUtilities.hh.

{ 1 };

Referenced by G4PlotManager::PlotAndWrite().

kZ

G4int G4Analysis::kZ { 2 }

constexpr

Definition at line 56 of file G4AnalysisUtilities.hh.

{ 2 };

Referenced by G4PlotManager::PlotAndWrite().