G4AccumulableManager Class Reference

#include <G4AccumulableManager.hh>

Public Member Functions
virtual	~G4AccumulableManager ()
template<typename T>
G4AccValue< T > *	CreateAccValue (const G4String &name, T value, G4MergeMode mergeMode=G4MergeMode::kAddition)
template<typename T>
G4AccValue< T > *	CreateAccValue (T value, G4MergeMode mergeMode=G4MergeMode::kAddition)
template<typename T>
G4AccValue< T > *	CreateAccumulable (const G4String &name, T value, G4MergeMode mergeMode=G4MergeMode::kAddition)
template<typename T>
G4AccValue< T > *	CreateAccumulable (T value, G4MergeMode mergeMode=G4MergeMode::kAddition)
template<typename T>
G4bool	Register (G4AccValue< T > &accumulable)
template<class T, std::size_t N>
G4bool	Register (G4AccArray< T, N > &accumulableArray)
template<class Key, class T, class Compare, class Allocator>
G4bool	Register (G4AccMap< Key, T, Compare, Allocator > &accumulableMap)
template<class Key, class T, class Hash, class KeyEqual, class Allocator>
G4bool	Register (G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator > &accumulableUnorderedMap)
template<class T, class Allocator>
G4bool	Register (G4AccVector< T, Allocator > &accumulableVector)
G4bool	Register (G4VAccumulable *accumulable)
template<typename T>
G4bool	RegisterAccumulable (G4AccValue< T > &accumulable)
G4bool	RegisterAccumulable (G4VAccumulable *accumulable)
template<typename T>
G4AccValue< T > *	GetAccValue (const G4String &name, G4bool warn=true) const
template<class T, std::size_t N>
G4AccArray< T, N > *	GetAccArray (const G4String &name, G4bool warn=true) const
template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
G4AccMap< Key, T, Compare, Allocator > *	GetAccMap (const G4String &name, G4bool warn=true) const
template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator > *	GetAccUnorderedMap (const G4String &name, G4bool warn=true) const
template<class T, class Allocator = std::allocator<T>>
G4AccVector< T, Allocator > *	GetAccVector (const G4String &name, G4bool warn=true) const
G4VAccumulable *	GetAccumulable (const G4String &name, G4bool warn=true) const
template<typename T>
G4AccValue< T > *	GetAccumulable (const G4String &name, G4bool warn=true) const
template<typename T>
G4AccValue< T > *	GetAccValue (G4int id, G4bool warn=true) const
template<class T, std::size_t N>
G4AccArray< T, N > *	GetAccArray (G4int id, G4bool warn=true) const
template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
G4AccMap< Key, T, Compare, Allocator > *	GetAccMap (G4int id, G4bool warn=true) const
template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>
G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator > *	GetAccUnorderedMap (G4int id, G4bool warn=true) const
template<class T, class Allocator = std::allocator<T>>
G4AccVector< T, Allocator > *	GetAccVector (G4int id, G4bool warn=true) const
G4VAccumulable *	GetAccumulable (G4int id, G4bool warn=true) const
template<typename T>
G4AccValue< T > *	GetAccumulable (G4int id, G4bool warn=true) const
G4int	GetNofAccumulables () const
std::vector< G4VAccumulable * >::iterator	Begin ()
std::vector< G4VAccumulable * >::iterator	End ()
std::vector< G4VAccumulable * >::const_iterator	BeginConst () const
std::vector< G4VAccumulable * >::const_iterator	EndConst () const
void	Merge ()
void	Reset ()
void	Print (G4PrintOptions options=G4PrintOptions()) const
void	Print (G4int startId, G4int count, G4PrintOptions options=G4PrintOptions()) const
void	Print (std::vector< G4VAccumulable * >::iterator startIt, std::size_t count, G4PrintOptions options=G4PrintOptions()) const
void	Print (std::vector< G4VAccumulable * >::iterator startIt, std::vector< G4VAccumulable * >::iterator endIt, G4PrintOptions options=G4PrintOptions()) const
void	SetVerboseLevel (G4int value)
G4int	GetVerboseLevel () const

Static Public Member Functions
static G4AccumulableManager *	Instance ()

Friends
class	G4ThreadLocalSingleton< G4AccumulableManager >

Detailed Description

Definition at line 54 of file G4AccumulableManager.hh.

Constructor & Destructor Documentation

~G4AccumulableManager()

G4AccumulableManager::~G4AccumulableManager ( )

virtual

Definition at line 66 of file G4AccumulableManager.cc.

{
  // delete only accumulables create by the mager itself
  for ( auto it : fAccumulablesToDelete ) {
    delete it;
  }
}

Member Function Documentation

Begin()

std::vector< G4VAccumulable * >::iterator G4AccumulableManager::Begin

(

)

BeginConst()

std::vector< G4VAccumulable * >::const_iterator G4AccumulableManager::BeginConst

(

)

const

CreateAccumulable() [1/2]

template<typename T>

G4AccValue< T > * G4AccumulableManager::CreateAccumulable	(	const G4String &	name,
		T	value,
		G4MergeMode	mergeMode = G4MergeMode::kAddition )

CreateAccumulable() [2/2]

template<typename T>

G4AccValue< T > * G4AccumulableManager::CreateAccumulable	(	T	value,
		G4MergeMode	mergeMode = G4MergeMode::kAddition )

CreateAccValue() [1/2]

template<typename T>

G4AccValue< T > * G4AccumulableManager::CreateAccValue	(	const G4String &	name,
		T	value,
		G4MergeMode	mergeMode = G4MergeMode::kAddition )

CreateAccValue() [2/2]

template<typename T>

G4AccValue< T > * G4AccumulableManager::CreateAccValue	(	T	value,
		G4MergeMode	mergeMode = G4MergeMode::kAddition )

End()

std::vector< G4VAccumulable * >::iterator G4AccumulableManager::End

(

)

EndConst()

std::vector< G4VAccumulable * >::const_iterator G4AccumulableManager::EndConst

(

)

const

GetAccArray() [1/2]

template<class T, std::size_t N>

G4AccArray< T, N > * G4AccumulableManager::GetAccArray	(	const G4String &	name,
		G4bool	warn = true ) const

GetAccArray() [2/2]

template<class T, std::size_t N>

G4AccArray< T, N > * G4AccumulableManager::GetAccArray	(	G4int	id,
		G4bool	warn = true ) const

GetAccMap() [1/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>

G4AccMap< Key, T, Compare, Allocator > * G4AccumulableManager::GetAccMap	(	const G4String &	name,
		G4bool	warn = true ) const

GetAccMap() [2/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>

G4AccMap< Key, T, Compare, Allocator > * G4AccumulableManager::GetAccMap	(	G4int	id,
		G4bool	warn = true ) const

GetAccumulable() [1/4]

G4VAccumulable * G4AccumulableManager::GetAccumulable	(	const G4String &	name,
		G4bool	warn = true ) const

Definition at line 168 of file G4AccumulableManager.cc.

{
  // get G4VParammeter from the map
  auto it = fMap.find(name);
  if ( it == fMap.end() ) {
    if ( warn) {
      G4ExceptionDescription description;
      description << "Accumulable " << name << " does not exist.";
      G4Exception("G4AccumulableManager::GetAccumulable",
                  "Analysis_W001", JustWarning, description);
    }
    return nullptr;
  }
 
  return it->second;
}

GetAccumulable() [2/4]

template<typename T>

G4AccValue< T > * G4AccumulableManager::GetAccumulable	(	const G4String &	name,
		G4bool	warn = true ) const

GetAccumulable() [3/4]

G4VAccumulable * G4AccumulableManager::GetAccumulable	(	G4int	id,
		G4bool	warn = true ) const

Definition at line 187 of file G4AccumulableManager.cc.

{
  // get G4VParammeter from the vector
  if ( id < 0 || id >= G4int(fVector.size()) ) {
    if ( warn) {
      G4ExceptionDescription description;
      description << "Accumulable " << id << " does not exist.";
      G4Exception("G4AccumulableManager::GetAccumulable",
                  "Analysis_W001", JustWarning, description);
    }
    return nullptr;
  }
 
  return fVector[id];
}

GetAccumulable() [4/4]

template<typename T>

G4AccValue< T > * G4AccumulableManager::GetAccumulable	(	G4int	id,
		G4bool	warn = true ) const

GetAccUnorderedMap() [1/2]

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>

G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator > * G4AccumulableManager::GetAccUnorderedMap	(	const G4String &	name,
		G4bool	warn = true ) const

GetAccUnorderedMap() [2/2]

template<class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>, class Allocator = std::allocator<std::pair<const Key, T>>>

G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator > * G4AccumulableManager::GetAccUnorderedMap	(	G4int	id,
		G4bool	warn = true ) const

GetAccValue() [1/2]

template<typename T>

G4AccValue< T > * G4AccumulableManager::GetAccValue	(	const G4String &	name,
		G4bool	warn = true ) const

GetAccValue() [2/2]

template<typename T>

G4AccValue< T > * G4AccumulableManager::GetAccValue	(	G4int	id,
		G4bool	warn = true ) const

GetAccVector() [1/2]

template<class T, class Allocator = std::allocator<T>>

G4AccVector< T, Allocator > * G4AccumulableManager::GetAccVector	(	const G4String &	name,
		G4bool	warn = true ) const

GetAccVector() [2/2]

template<class T, class Allocator = std::allocator<T>>

G4AccVector< T, Allocator > * G4AccumulableManager::GetAccVector	(	G4int	id,
		G4bool	warn = true ) const

GetNofAccumulables()

G4int G4AccumulableManager::GetNofAccumulables

(

)

const

GetVerboseLevel()

G4int G4AccumulableManager::GetVerboseLevel

(

)

const

Instance()

G4AccumulableManager * G4AccumulableManager::Instance ( )

static

Definition at line 51 of file G4AccumulableManager.cc.

{
  static G4ThreadLocalSingleton<G4AccumulableManager> instance;
  return instance.Instance();
}

Merge()

void G4AccumulableManager::Merge

(

)

Definition at line 204 of file G4AccumulableManager.cc.

{
  // Do nothing if  there are no accumulables registered
  // or if master thread
  if ((fVector.size() == 0u) || (!G4Threading::IsWorkerThread())) {
    return;
  }
 
  // The manager on mastter must exist
  if (fgMasterInstance == nullptr) {
    G4ExceptionDescription description;
    description
      << "No master G4AccumulableManager instance exists." << G4endl
      << "Accumulables will not be merged.";
      G4Exception("G4AccumulableManager::Merge()",
                "Analysis_W001", JustWarning, description);
    return;
  }
 
  // The worker manager just merges its accumulables to the master
  // This operation needs a lock
  // G4cout << "Go to merge accumulables" << G4endl;
  G4AutoLock lock(&mergeMutex);
 
  // the other manager has the vector with the "same" accumulables
  auto it = fVector.begin();
  for ( auto itMaster : fgMasterInstance->fVector ) {
    // G4VAccumulable* masterAccumulable = itMaster;
    // G4VAccumulable* accumulable = *(it++);
    // masterAccumulable->Merge(*(accumulable));
    itMaster->Merge(*(*(it++)));
  }
  lock.unlock();
}

Print() [1/4]

void G4AccumulableManager::Print	(	G4int	startId,
		G4int	count,
		G4PrintOptions	options = G4PrintOptions() ) const

Definition at line 258 of file G4AccumulableManager.cc.

{
  // check if range is within limits
  if ( startId < 0 || startId >= G4int(fVector.size()) ||
       count <= 0 || startId + count > G4int(fVector.size()) ) {
    RangeException("Print",
      std::to_string(startId) + ", " + std::to_string(count));
    return;
  }
 
  for ( auto id = startId; id < startId + count; ++id ) {
    fVector[id]->Print(options);
  }
}

Print() [2/4]

void G4AccumulableManager::Print

(

G4PrintOptions

options = G4PrintOptions()

)

const

Definition at line 250 of file G4AccumulableManager.cc.

{
  for ( auto it : fVector ) {
    it->Print(options);
  }
}

Referenced by Print().

Print() [3/4]

void G4AccumulableManager::Print	(	std::vector< G4VAccumulable * >::iterator	startIt,
		std::size_t	count,
		G4PrintOptions	options = G4PrintOptions() ) const

Definition at line 292 of file G4AccumulableManager.cc.

{
  Print(startIt, startIt+count, options);
}

Print() [4/4]

void G4AccumulableManager::Print	(	std::vector< G4VAccumulable * >::iterator	startIt,
		std::vector< G4VAccumulable * >::iterator	endIt,
		G4PrintOptions	options = G4PrintOptions() ) const

Definition at line 275 of file G4AccumulableManager.cc.

{
  // check if range is within limits
  if ( startIt == fVector.end() || endIt == fVector.end() ) {
    RangeException("Print", "[startIt, endIt]");
    return;
  }
 
  for ( auto it = startIt; it != endIt; ++it ) {
    (*it)->Print(options);
  }
}

Register() [1/6]

template<class T, std::size_t N>

G4bool G4AccumulableManager::Register

(

G4AccArray< T, N > &

accumulableArray

)

Register() [2/6]

template<class Key, class T, class Compare, class Allocator>

G4bool G4AccumulableManager::Register

(

G4AccMap< Key, T, Compare, Allocator > &

accumulableMap

)

Register() [3/6]

template<class Key, class T, class Hash, class KeyEqual, class Allocator>

G4bool G4AccumulableManager::Register

(

G4AccUnorderedMap< Key, T, Hash, KeyEqual, Allocator > &

accumulableUnorderedMap

)

Register() [4/6]

template<typename T>

G4bool G4AccumulableManager::Register

(

G4AccValue< T > &

accumulable

)

Referenced by RegisterAccumulable().

Register() [5/6]

template<class T, class Allocator>

G4bool G4AccumulableManager::Register

(

G4AccVector< T, Allocator > &

accumulableVector

)

Register() [6/6]

G4bool G4AccumulableManager::Register

(

G4VAccumulable *

accumulable

)

Definition at line 127 of file G4AccumulableManager.cc.

{
  auto name = accumulable->GetName();
 
  if (G4Accumulables::VerboseLevel > 1 ) {
    G4cout << "Going to register accumulable \"" << name << "\"" << G4endl;
  }
 
  // do not accept name if it is already used
  if (!CheckName(name, "RegisterAccumulable")) {
    return false;
  }
 
  // generate name if empty
  if (name.length() == 0u) {
    name =  GenerateName();
    accumulable->SetName(name);
  }
 
  // set Id
  accumulable->SetId((G4int)fVector.size());
 
  fMap[name] = accumulable;
  fVector.push_back(accumulable);
 
  if (G4Accumulables::VerboseLevel > 0 ) {
    G4cout << "Accumulable registered as \"" << accumulable->GetName() << "\"" << G4endl;
  }
 
  return true;
}

RegisterAccumulable() [1/2]

template<typename T>

G4bool G4AccumulableManager::RegisterAccumulable

(

G4AccValue< T > &

accumulable

)

RegisterAccumulable() [2/2]

G4bool G4AccumulableManager::RegisterAccumulable

(

G4VAccumulable *

accumulable

)

Definition at line 161 of file G4AccumulableManager.cc.

{
  return Register(accumulable);
}

Reset()

void G4AccumulableManager::Reset

(

)

Definition at line 240 of file G4AccumulableManager.cc.

{
// Reset all accummulables
 
  for ( auto it : fVector ) {
    it->Reset();
  }
}

SetVerboseLevel()

void G4AccumulableManager::SetVerboseLevel

(

G4int

value

)

Friends And Related Symbol Documentation

G4ThreadLocalSingleton< G4AccumulableManager >

friend class G4ThreadLocalSingleton< G4AccumulableManager >

friend

Definition at line 1 of file G4AccumulableManager.hh.

---

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

• G4AccumulableManager.hh
• G4AccumulableManager.cc