G4RootMpiPNtupleManager Class Reference

#include <G4RootMpiPNtupleManager.hh>

Inheritance diagram for G4RootMpiPNtupleManager:

Public Member Functions
	G4RootMpiPNtupleManager (const G4AnalysisManagerState &state, tools::impi *impi, G4int mpiRank, G4int destinationRank)
	~G4RootMpiPNtupleManager ()
template<>
G4bool	FillNtupleTColumn (G4int ntupleId, G4int columnId, const std::string &value)

Private Member Functions
void	SetFileManager (std::shared_ptr< G4RootFileManager > fileManager)
void	CreateNtuple (G4RootMpiPNtupleDescription *ntupleDescription)
void	CreateNtuplesFromBooking (const std::vector< G4NtupleBooking * > &ntupleBookings)
virtual G4int	CreateNtuple (G4NtupleBooking *booking) final
virtual G4bool	FillNtupleIColumn (G4int ntupleId, G4int columnId, G4int value) final
virtual G4bool	FillNtupleFColumn (G4int ntupleId, G4int columnId, G4float value) final
virtual G4bool	FillNtupleDColumn (G4int ntupleId, G4int columnId, G4double value) final
virtual G4bool	FillNtupleSColumn (G4int ntupleId, G4int columnId, const G4String &value) final
virtual G4bool	AddNtupleRow (G4int ntupleId) final
virtual G4bool	Merge () final
virtual G4bool	Reset () final
virtual void	Clear () final
G4bool	Delete (G4int id) final
virtual void	SetActivation (G4bool activation) final
virtual void	SetActivation (G4int ntupleId, G4bool activation) final
virtual G4bool	GetActivation (G4int ntupleId) const final
void	SetNewCycle (G4bool value) final
G4bool	GetNewCycle () const final
virtual G4int	GetNofNtuples () const final
G4RootMpiPNtupleDescription *	GetNtupleDescriptionInFunction (G4int id, G4String function, G4bool warn=true) const
tools::wroot::base_pntuple *	GetNtupleInFunction (G4int id, G4String function, G4bool warn=true) const
template<typename T >
G4bool	FillNtupleTColumn (G4int ntupleId, G4int columnId, const T &value)

Private Attributes
std::shared_ptr< G4RootFileManager >	fFileManager
std::vector< G4RootMpiPNtupleDescription * >	fNtupleDescriptionVector
std::vector< tools::wroot::impi_ntuple * >	fNtupleVector
tools::impi *	fImpi
G4int	fMpiRank
G4int	fDestinationRank
G4bool	fNewCycle { false }

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

Friends
class	G4RootMpiNtupleFileManager

Detailed Description

Definition at line 61 of file G4RootMpiPNtupleManager.hh.

Constructor & Destructor Documentation

G4RootMpiPNtupleManager()

G4RootMpiPNtupleManager::G4RootMpiPNtupleManager	(	const G4AnalysisManagerState &	state,
		tools::impi *	impi,
		G4int	mpiRank,
		G4int	destinationRank
	)

Definition at line 56 of file G4RootMpiPNtupleManager.cc.

 : G4BaseNtupleManager(state),
   fNtupleVector(),
   fImpi(impi),
   fMpiRank(mpiRank),
   fDestinationRank(destinationRank)
{
}

~G4RootMpiPNtupleManager()

G4RootMpiPNtupleManager::~G4RootMpiPNtupleManager

(

)

Definition at line 68 of file G4RootMpiPNtupleManager.cc.

{
  for ( auto ntupleDescription : fNtupleDescriptionVector ) {
    delete ntupleDescription;
  }   
}

Member Function Documentation

SetFileManager()

void G4RootMpiPNtupleManager::SetFileManager ( std::shared_ptr< G4RootFileManager >  fileManager )

inlineprivate

Definition at line 145 of file G4RootMpiPNtupleManager.hh.

{ fFileManager = fileManager; }

CreateNtuple() [1/2]

void G4RootMpiPNtupleManager::CreateNtuple ( G4RootMpiPNtupleDescription *  ntupleDescription )

private

Definition at line 116 of file G4RootMpiPNtupleManager.cc.

{
  Message(kVL4, "create from booking", "mpi pntuple",
    ntupleDescription->GetDescription().GetNtupleBooking().name());
 
  // Wait for the ntuple data from main
 
  G4bool verbose = IsVerbose(kVL2);
 
  G4cout << "Go to wait_buffer from " << fDestinationRank << G4endl;
  fImpi->pack_reset();
  int probe_src;
  if ( ! fImpi->wait_buffer(fMpiRank, fDestinationRank, kTAG_NTUPLE, probe_src, verbose)) {
    G4cerr << "G4RootMpiPNtupleManager::CreateNtuple: wait_buffer() failed."<< G4endl;
    return;
  }
  G4cout << "After wait_buffer with " << fImpi << G4endl;
 
  tools::uint32 mainNtupleId;
  bool rowWise;
  bool byteSwap;
  unsigned int compression;
  tools::wroot::seek seekDirectory;
  tools::uint32 basketSize;
  bool rowMode;
  std::vector<tools::uint32> basketSizes;
  unsigned int basketEntries;
 
  if ( ! fImpi->unpack(mainNtupleId) ) {
    G4cerr << "bunpack(byteSwap) failed."<< G4endl;
    return;
  }
  // G4cout << "unpack 1" << G4endl;
  
  if ( ! fImpi->bunpack(rowWise) ) {
    G4cerr << "bunpack(rowWise) failed."<< G4endl;
    return;
  }
  // G4cout << "unpack 1/2" << G4endl;
 
  if ( ! fImpi->bunpack(byteSwap) ) {
    G4cerr << "bunpack(byteSwap) failed."<< G4endl;
    return;
  }
  // G4cout << "unpack 2" << G4endl;
  
  if ( ! fImpi->unpack(compression) ) {
    G4cerr << "unpack(compression) failed."<< G4endl;
    return;
  }
  // G4cout << "unpack 3" << G4endl;
 
  if ( ! fImpi->unpack(seekDirectory) ) {
    G4cerr << "unpack(seek) failed."<< G4endl;
    return;
  }
  // G4cout << "unpack 4" << G4endl;
  
  if (rowWise) {
    if ( ! fImpi->unpack(basketSize) ) {
      G4cerr << "unpack(basketSize) failed."<< G4endl;
      return;
    }
  } else {
    if ( ! fImpi->bunpack(rowMode) ) {
      G4cerr << "bpack(rowMode) failed." << G4endl;
      return;
    }      
    if ( ! fImpi->vunpack(basketSizes) ) {
      G4cerr << "vunpack(basketSizes) failed."<< G4endl;
      return;
    }
    if( ! fImpi->unpack(basketEntries) ) {
      G4cerr << "unpack(basketEntries) failed." << G4endl;
      return;
    }
  }
  // G4cout << "unpack 5" << G4endl;
 
  // G4cout << "rank = " << fMpiRank
  //           << ", verbose = " << verbose
  //           << ", mainNtupleId = " << mainNtupleId 
  //           << ", byteSwap = " << byteSwap
  //           << ", compression = " << compression
  //           << ", seekDirectory = " << seekDirectory
  //           << ", basketSizes.size() = " << basketSizes.size()
  //           << G4endl;
 
  // Create MPI pntuple
  if ( rowWise ) {
    tools::wroot::mpi_ntuple_row_wise* ntuple
      = new tools::wroot::mpi_ntuple_row_wise(
              mainNtupleId, G4cout, byteSwap, compression, seekDirectory,
              basketSize, ntupleDescription->GetDescription().GetNtupleBooking(), verbose);
    ntupleDescription->SetNtuple(ntuple);
    ntupleDescription->SetBasePNtuple(ntuple);
  } else {
    tools::wroot::mpi_ntuple_column_wise* ntuple
      = new tools::wroot::mpi_ntuple_column_wise(
              mainNtupleId, G4cout, byteSwap, compression, seekDirectory,
              basketSizes, ntupleDescription->GetDescription().GetNtupleBooking(),
              rowMode, basketEntries, verbose);
    ntupleDescription->SetNtuple(ntuple);
    ntupleDescription->SetBasePNtuple(ntuple);
  }
 
  ntupleDescription->GetDescription().SetIsNtupleOwner(true);
  ntupleDescription->SetImpi(fImpi);
         // should be not needed
         // pntuple object is not deleted automatically
  fNtupleVector.push_back(ntupleDescription->GetNtuple());
 
  Message(kVL3, "create from booking", "mpi pntuple",
    ntupleDescription->GetDescription().GetNtupleBooking().name());
}

CreateNtuplesFromBooking()

void G4RootMpiPNtupleManager::CreateNtuplesFromBooking ( const std::vector< G4NtupleBooking * > &  ntupleBookings )

private

Definition at line 233 of file G4RootMpiPNtupleManager.cc.

{
// Create ntuple from ntuple_booking & the buffer from main rank
 
  // G4cout << "Start G4RootMpiPNtupleManager::CreateNtuplesFromBooking" << G4endl;
 
  // Do not create ntuples if NtupleVector is not empty
  if ( fNtupleVector.size() ) return;
 
  // Create pntuple descriptions from ntuple booking.
  // auto g4NtupleBookings = fBookingManager->GetNtupleBookingVector();
  for ( auto g4NtupleBooking : ntupleBookings ) {
    auto ntupleDescription = new G4RootMpiPNtupleDescription(g4NtupleBooking);
    ntupleDescription->SetMainNtupleRank(fDestinationRank);
    fNtupleDescriptionVector.push_back(ntupleDescription);  
  }
 
  // Create mpi ntuples
  for ( auto ntupleDescription : fNtupleDescriptionVector ) {
 
    // Do not create ntuple if it is inactivated 
    if ( fState.GetIsActivation() && ( ! ntupleDescription->GetDescription().GetActivation() ) ) continue;
    
    // Do not create ntuple if it already exists
    if ( ntupleDescription->GetNtuple() ) continue;
    
    Message(kVL4, "create from booking", "mpi pntuple",
      ntupleDescription->GetDescription().GetNtupleBooking().name());
 
    // create ntuple
    CreateNtuple(ntupleDescription);
 
    // finish created ntuple 
    // (nothing to be done ?)
    // FinishTNtuple(ntupleDescription);
 
    Message(kVL3, "create from booking", "mpi pntuple",
      ntupleDescription->GetDescription().GetNtupleBooking().name());
  }
 
}   

CreateNtuple() [2/2]

G4int G4RootMpiPNtupleManager::CreateNtuple ( G4NtupleBooking *  booking )

finalprivatevirtual

Definition at line 277 of file G4RootMpiPNtupleManager.cc.

{
// Create pntuple description from g4 ntuple booking
// Nothing to be done here.
 
  return G4Analysis::kInvalidId;
}                                         

FillNtupleIColumn()

G4bool G4RootMpiPNtupleManager::FillNtupleIColumn ( G4int  ntupleId, G4int  columnId, G4int  value  )

finalprivatevirtual

Definition at line 287 of file G4RootMpiPNtupleManager.cc.

{
  return FillNtupleTColumn<int>(ntupleId, columnId, value);
}                                         

FillNtupleFColumn()

G4bool G4RootMpiPNtupleManager::FillNtupleFColumn ( G4int  ntupleId, G4int  columnId, G4float  value  )

finalprivatevirtual

Definition at line 294 of file G4RootMpiPNtupleManager.cc.

{
  return FillNtupleTColumn<float>(ntupleId, columnId, value);
}                                         

FillNtupleDColumn()

G4bool G4RootMpiPNtupleManager::FillNtupleDColumn ( G4int  ntupleId, G4int  columnId, G4double  value  )

finalprivatevirtual

Definition at line 301 of file G4RootMpiPNtupleManager.cc.

{
  return FillNtupleTColumn<double>(ntupleId, columnId, value);
}                                         

FillNtupleSColumn()

G4bool G4RootMpiPNtupleManager::FillNtupleSColumn ( G4int  ntupleId, G4int  columnId, const G4String &  value  )

finalprivatevirtual

Definition at line 308 of file G4RootMpiPNtupleManager.cc.

{
  return FillNtupleTColumn<std::string>(ntupleId, columnId, value);
}                                         

AddNtupleRow()

G4bool G4RootMpiPNtupleManager::AddNtupleRow ( G4int  ntupleId )

finalprivatevirtual

Definition at line 315 of file G4RootMpiPNtupleManager.cc.

{ 
  if ( fState.GetIsActivation() && ( ! GetActivation(ntupleId) ) ) {
    //G4cout << "Skipping AddNtupleRow for " << ntupleId << G4endl; 
    return false; 
  }  
 
  Message(kVL4, "add", "pntuple row", " ntupleId " + to_string(ntupleId));
 
  auto ntupleDescription = GetNtupleDescriptionInFunction(ntupleId, "AddNtupleRow");
  if ( ! ntupleDescription ) return false;
  
  // if(!_ntuple->add_row(_impi,rank_src,tag)) {
  auto result 
    = ntupleDescription->GetNtuple()
      ->add_row(*fImpi, ntupleDescription->GetMainNtupleRank(), kTAG_NTUPLE );
 
  if ( ! result ) {
    G4ExceptionDescription description;
    description << "      " << " ntupleId " << ntupleId 
                << "adding row has failed.";
    G4Exception("G4RootMpiPNtupleManager::AddNtupleRow()",
                "Analysis_W002", JustWarning, description);
  }         
 
  Message(kVL3, "add", "pntuple row", " ntupleId " + to_string(ntupleId));
 
  return true;
}

Merge()

G4bool G4RootMpiPNtupleManager::Merge ( )

finalprivatevirtual

Definition at line 346 of file G4RootMpiPNtupleManager.cc.

{
 
  // G4cout << "Start G4RootMpiPNtupleManager::Merge" << G4endl;
 
  auto finalResult = true;
 
  for ( auto ntupleDescription : fNtupleDescriptionVector) {
 
    // skip inactivated ntuples
    if ( ! ntupleDescription->GetDescription().GetActivation() ) continue;
  
    // skip if ntuple was already merged and deleted
    // (this happend when the main rank re-opens a new file for merged data)
    if ( ! ntupleDescription->GetNtuple() ) continue;
  
    Message(kVL4, "merge", "pntuple", ntupleDescription->GetDescription().GetNtupleBooking().name());
 
    // G4cout << "call end_fill " << fImpi 
    //        << " to rank " << ntupleDescription->GetMainNtupleRank()
    //        << " pntuple: " << ntupleDescription->GetNtuple() << G4endl;
    auto result 
      = ntupleDescription->GetNtuple()
        ->end_fill(*fImpi, ntupleDescription->GetMainNtupleRank(), kTAG_NTUPLE);
 
    if ( ! result ) {
      G4ExceptionDescription description;
      description << "      " << " ntuple " << ntupleDescription->GetDescription().GetNtupleBooking().name()
                  << "end fill has failed.";
      G4Exception("G4RootMpiPNtupleManager::Merge()",
                  "Analysis_W002", JustWarning, description);
    }
 
    delete ntupleDescription->GetNtuple();
    ntupleDescription->SetNtuple(nullptr);
  
    Message(kVL3, "merge", "pntuple", ntupleDescription->GetDescription().GetNtupleBooking().name());
  }
 
  return finalResult;
}

Reset()

G4bool G4RootMpiPNtupleManager::Reset ( )

finalprivatevirtual

Definition at line 389 of file G4RootMpiPNtupleManager.cc.

{
  // Reset ntuple description, this will delete ntuple if present and
  // we have its ownership.
  // The ntuples will be recreated with new cycle or new open file.
 
  for ( auto ntupleDescription : fNtupleDescriptionVector ) {
    ntupleDescription->GetDescription().Reset();
  }
 
  fNtupleVector.clear();
 
  return true;
}

Clear()

void G4RootMpiPNtupleManager::Clear ( )

finalprivatevirtual

Definition at line 405 of file G4RootMpiPNtupleManager.cc.

{
  for ( auto ntupleDescription : fNtupleDescriptionVector ) {
    delete ntupleDescription->GetNtuple();
  }
 
  fNtupleDescriptionVector.clear();
  fNtupleVector.clear();
 
  Message(kVL2, "clear", "pntuples");
}

Delete()

G4bool G4RootMpiPNtupleManager::Delete ( G4int  id )

finalprivate

Definition at line 418 of file G4RootMpiPNtupleManager.cc.

{
  if ( IsVerbose(G4Analysis::kVL4) ) {
    Message(G4Analysis::kVL4, "delete", "pntuple ntupleId " + to_string(id));
  }
 
  auto ntupleDescription = GetNtupleDescriptionInFunction(id, "Delete", true);
 
  if (ntupleDescription == nullptr) return false;
 
  // Delete/clear ntuple data
  delete ntupleDescription->GetNtuple();
  ntupleDescription->SetNtuple(nullptr);
  ntupleDescription->SetBasePNtuple(nullptr);
  ntupleDescription->GetMainBranches().clear();
 
  // Update ntuple vector
  auto index = id - GetFirstId();
  fNtupleVector[index] = nullptr;
 
  Message(G4Analysis::kVL2, "delete", "pntuple ntupleId " + to_string(id));
 
  return true;
}

SetActivation() [1/2]

void G4RootMpiPNtupleManager::SetActivation ( G4bool  activation )

finalprivatevirtual

Definition at line 445 of file G4RootMpiPNtupleManager.cc.

{
  for ( auto ntupleDescription : fNtupleDescriptionVector ) {
    ntupleDescription->GetDescription().SetActivation(activation);
  } 
}

SetActivation() [2/2]

void G4RootMpiPNtupleManager::SetActivation ( G4int  ntupleId, G4bool  activation  )

finalprivatevirtual

Definition at line 455 of file G4RootMpiPNtupleManager.cc.

{
  auto ntupleDescription = GetNtupleDescriptionInFunction(ntupleId, "SetActivation");
  if ( ! ntupleDescription ) return;
 
  ntupleDescription->GetDescription().SetActivation(activation);
}

GetActivation()

G4bool G4RootMpiPNtupleManager::GetActivation ( G4int  ntupleId ) const

finalprivatevirtual

Definition at line 465 of file G4RootMpiPNtupleManager.cc.

{
  auto ntupleDescription = GetNtupleDescriptionInFunction(ntupleId, "GetActivation");
  if ( ! ntupleDescription ) return false;
 
  return ntupleDescription->GetDescription().GetActivation();
}

SetNewCycle()

void G4RootMpiPNtupleManager::SetNewCycle ( G4bool  value )

finalprivate

Definition at line 475 of file G4RootMpiPNtupleManager.cc.

{
  fNewCycle = value;
}

GetNewCycle()

G4bool G4RootMpiPNtupleManager::GetNewCycle ( ) const

finalprivate

Definition at line 481 of file G4RootMpiPNtupleManager.cc.

{
  return fNewCycle;
}

GetNofNtuples()

G4int G4RootMpiPNtupleManager::GetNofNtuples ( ) const

finalprivatevirtual

Definition at line 487 of file G4RootMpiPNtupleManager.cc.

{
  return fNtupleVector.size();
}

GetNtupleDescriptionInFunction()

G4RootMpiPNtupleDescription * G4RootMpiPNtupleManager::GetNtupleDescriptionInFunction ( G4int  id, G4String  function, G4bool  warn = true  ) const

private

Definition at line 81 of file G4RootMpiPNtupleManager.cc.

{                                      
  auto index = id - fFirstId;
  if ( index < 0 || index >= G4int(fNtupleDescriptionVector.size()) ) {
    if ( warn) {
      NotExistException("ntuple description", id, functionName);
    }
    return nullptr;         
  }
  
  return fNtupleDescriptionVector[index];
}

GetNtupleInFunction()

tools::wroot::base_pntuple * G4RootMpiPNtupleManager::GetNtupleInFunction ( G4int  id, G4String  function, G4bool  warn = true  ) const

private

Definition at line 96 of file G4RootMpiPNtupleManager.cc.

{                                      
  auto ntupleDescription = GetNtupleDescriptionInFunction(id, functionName);
  if ( ! ntupleDescription ) return nullptr;
 
  if ( ! ntupleDescription->GetBasePNtuple() ) {
    if ( warn ) {
      NotExistException("ntuple", id, functionName);
    }
    return nullptr;
  }  
  return ntupleDescription->GetBasePNtuple();
}

FillNtupleTColumn() [1/2]

template<typename T >

G4bool G4RootMpiPNtupleManager::FillNtupleTColumn ( G4int  ntupleId, G4int  columnId, const T &  value  )

private

Definition at line 203 of file G4RootMpiPNtupleManager.hh.

{
  if ( fState.GetIsActivation() && ( ! GetActivation(ntupleId) ) ) {
    G4cout << "Skipping FillNtupleIColumn for " << ntupleId << G4endl; 
    return false; 
  }  
 
  if ( IsVerbose(G4Analysis::kVL4) ) {
    Message(G4Analysis::kVL4, "fill", "pntuple T column",
       " ntupleId " + to_string(ntupleId) +
       " columnId " + to_string(columnId) +
       " value " + G4Analysis::ToString(value));
  }
 
  // get ntuple
  auto ntuple = GetNtupleInFunction(ntupleId, "FillNtupleTColumn");
  if ( ! ntuple ) return false;
 
  // get generic column
  auto index = columnId - fFirstNtupleColumnId;
  if ( index < 0 || index >= G4int(ntuple->columns().size()) ) {
    G4ExceptionDescription description;
    description << "      "  << "ntupleId " << ntupleId
                << " columnId " << columnId << " does not exist.";
    G4Exception("G4TNtupleManager::FillNtupleTColumn()",
                "Analysis_W011", JustWarning, description);
    return false;
  }
  auto icolumn =  ntuple->columns()[index];
 
  // get column and check its type
  auto column = dynamic_cast<tools::wroot::base_pntuple::column<T>* >(icolumn);
  if ( ! column ) {
    G4ExceptionDescription description;
    description << " Column type does not match: "
                << " ntupleId " << ntupleId  
                << " columnId " << columnId << " value " << value;
    G4Exception("G4TNtupleManager:FillNtupleTColumn",
                "Analysis_W011", JustWarning, description);
    return false;
  } 
 
  column->fill(value);
 
  if ( IsVerbose(G4Analysis::kVL4) ) {
    Message(G4Analysis::kVL4, "done fill", "pntuple T column",
       " ntupleId " + to_string(ntupleId) +
       " columnId " + to_string(columnId) +
       " value " + G4Analysis::ToString(value));
  }
 
  return true;  
}

FillNtupleTColumn() [2/2]

template<>

G4bool G4RootMpiPNtupleManager::FillNtupleTColumn ( G4int  ntupleId, G4int  columnId, const std::string &  value  )

inline

Definition at line 150 of file G4RootMpiPNtupleManager.hh.

{
  if ( fState.GetIsActivation() && ( ! GetActivation(ntupleId) ) ) {
    G4cout << "Skipping FillNtupleIColumn for " << ntupleId << G4endl; 
    return false; 
  } 
 
  if ( IsVerbose(G4Analysis::kVL4) ) {
    Message(G4Analysis::kVL4, "fill", "pntuple T column",
       " ntupleId " + to_string(ntupleId) + " columnId " + to_string(columnId) +
       " value " + G4Analysis::ToString(value));
  }
 
  auto ntuple = GetNtupleInFunction(ntupleId, "FillNtupleTColumn");
  if ( ! ntuple ) return false;
 
  auto index = columnId - fFirstNtupleColumnId;
  if ( index < 0 || index >= G4int(ntuple->columns().size()) ) {
    G4ExceptionDescription description;
    description << "      "  << "ntupleId " << ntupleId
                << " columnId " << columnId << " does not exist.";
    G4Exception("G4RootNtupleManager::FillNtupleTColumn()",
                "Analysis_W011", JustWarning, description);
    return false;
  }
 
  auto icolumn =  ntuple->columns()[index];
  auto column = dynamic_cast<tools::wroot::base_pntuple::column_string* >(icolumn);
  if ( ! column ) {
    G4ExceptionDescription description;
    description << " Column type does not match: "
                << " ntupleId " << ntupleId  
                << " columnId " << columnId << " value " << value;
    G4Exception("G4RootNtupleManager:FillNtupleColumn",
                "Analysis_W011", JustWarning, description);
    return false;
  } 
 
  column->fill(value);
 
  if ( IsVerbose(G4Analysis::kVL4) ) {
    Message(G4Analysis::kVL4, "done fill", "pntuple T column",
      " ntupleId " + to_string(ntupleId) +
      " columnId " + to_string(columnId) +
      " value " + value);
  }
 
  return true;  
}

Friends And Related Symbol Documentation

G4RootMpiNtupleFileManager

friend class G4RootMpiNtupleFileManager

friend

Definition at line 63 of file G4RootMpiPNtupleManager.hh.

Member Data Documentation

fkClass

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

staticconstexprprivate

Definition at line 129 of file G4RootMpiPNtupleManager.hh.

{ "G4RootMpiPNtupleManager" };

fFileManager

std::shared_ptr<G4RootFileManager> G4RootMpiPNtupleManager::fFileManager

private

Definition at line 133 of file G4RootMpiPNtupleManager.hh.

fNtupleDescriptionVector

std::vector<G4RootMpiPNtupleDescription*> G4RootMpiPNtupleManager::fNtupleDescriptionVector

private

Definition at line 134 of file G4RootMpiPNtupleManager.hh.

fNtupleVector

std::vector<tools::wroot::impi_ntuple*> G4RootMpiPNtupleManager::fNtupleVector

private

Definition at line 135 of file G4RootMpiPNtupleManager.hh.

fImpi

tools::impi* G4RootMpiPNtupleManager::fImpi

private

Definition at line 136 of file G4RootMpiPNtupleManager.hh.

fMpiRank

G4int G4RootMpiPNtupleManager::fMpiRank

private

Definition at line 137 of file G4RootMpiPNtupleManager.hh.

fDestinationRank

G4int G4RootMpiPNtupleManager::fDestinationRank

private

Definition at line 138 of file G4RootMpiPNtupleManager.hh.

fNewCycle

G4bool G4RootMpiPNtupleManager::fNewCycle { false }

private

Definition at line 139 of file G4RootMpiPNtupleManager.hh.

{ false };

---

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

• extended/parallel/MPI/source/analysis/include/G4RootMpiPNtupleManager.hh
• extended/parallel/MPI/source/analysis/src/G4RootMpiPNtupleManager.cc