G4MPImanager Class Reference

#include <G4MPImanager.hh>

Collaboration diagram for G4MPImanager:

Public Types
enum	{ kRANK_MASTER = 0 }
enum	{   kTAG_G4COMMAND = 100, kTAG_G4STATUS = 200, kTAG_G4SEED = 300, kTAG_DATA = 1000,   kTAG_HISTO = 1001, kTAG_RUN = 1002, kTAG_CMDSCR = 1003 }

Public Member Functions
	G4MPImanager ()
	G4MPImanager (int argc, char **argv)
	~G4MPImanager ()
G4MPIsession *	GetMPIsession () const
G4int	GetVerbose () const
void	SetVerbose (G4int iverbose)
G4int	GetSize () const
G4int	GetRank () const
G4bool	IsMaster () const
G4bool	IsSlave () const
G4bool	IsInitMacro () const
const G4String &	GetInitFileName () const
G4bool	IsBatchMode () const
const G4String &	GetMacroFileName () const
void	SetMasterWeight (G4double aweight)
G4double	GetMasterWeight () const
G4VMPIseedGenerator *	GetSeedGenerator () const
G4String	BcastCommand (const G4String &command)
void	ShowStatus ()
void	ShowSeeds ()
void	SetSeed (G4int inode, G4long seed)
void	WaitBeamOn ()
void	DistributeSeeds ()
void	ExecuteMacroFile (const G4String &fname, G4bool qbatch=false)
G4bool	CheckThreadStatus ()
void	ExecuteThreadCommand (const G4String &command)
void	ExecuteBeamOnThread (const G4String &command)
void	JoinBeamOnThread ()
void	BeamOn (G4int nevent, G4bool qdivide=true)
void	Print (const G4String &message)
void	ShowHelp () const

Static Public Member Functions
static G4MPImanager *	GetManager ()

Private Member Functions
	DISALLOW_COPY_AND_ASSIGN (G4MPImanager)
void	Initialize ()
void	ParseArguments (G4int argc, char **argv)
void	UpdateStatus ()

Private Attributes
G4MPImessenger *	messenger_
G4MPIsession *	session_
G4VMPIseedGenerator *	seed_generator_
G4MPIstatus *	status_
G4int	verbose_
G4bool	is_master_
G4bool	is_slave_
G4int	rank_
G4int	size_
MPI::Intracomm	COMM_G4COMMAND_
G4bool	qfcout_
std::ofstream	fscout_
G4bool	qinitmacro_
G4String	init_file_name_
G4bool	qbatchmode_
G4String	macro_file_name_
pthread_t	thread_id_
G4double	master_weight_

Static Private Attributes
static G4MPImanager *	g4mpi_ = NULL

Detailed Description

Definition at line 45 of file G4MPImanager.hh.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
kRANK_MASTER

Definition at line 48 of file G4MPImanager.hh.

{ kRANK_MASTER = 0 };

anonymous enum

anonymous enum

Enumerator
kTAG_G4COMMAND
kTAG_G4STATUS
kTAG_G4SEED
kTAG_DATA
kTAG_HISTO
kTAG_RUN
kTAG_CMDSCR

Definition at line 50 of file G4MPImanager.hh.

       { // MPI tag
    kTAG_G4COMMAND = 100,
    kTAG_G4STATUS = 200,
    kTAG_G4SEED = 300,
    kTAG_DATA = 1000,
    kTAG_HISTO = 1001,
    kTAG_RUN = 1002,
    kTAG_CMDSCR = 1003
  };

Constructor & Destructor Documentation

G4MPImanager() [1/2]

G4MPImanager::G4MPImanager

(

)

Definition at line 68 of file G4MPImanager.cc.

  : verbose_(0), qfcout_(false), qinitmacro_(false), qbatchmode_(false),
    thread_id_(0), master_weight_(1.)
{
  //MPI::Init();
  MPI::Init_thread(MPI::THREAD_SERIALIZED);
  Initialize();
}

Here is the call graph for this function:

G4MPImanager() [2/2]

G4MPImanager::G4MPImanager	(	int	argc,
		char **	argv
	)

Definition at line 78 of file G4MPImanager.cc.

  : verbose_(0), qfcout_(false), qinitmacro_(false), qbatchmode_(false),
    thread_id_(0), master_weight_(1.)
{
  //MPI::Init(argc, argv);
  MPI::Init_thread(argc, argv, MPI::THREAD_SERIALIZED);
  Initialize();
  ParseArguments(argc, argv);
}

Here is the call graph for this function:

~G4MPImanager()

G4MPImanager::~G4MPImanager

(

)

Definition at line 89 of file G4MPImanager.cc.

{
  if( is_slave_ && qfcout_ ) fscout_.close();

  delete status_;
  delete messenger_;
  delete session_;

  COMM_G4COMMAND_.Free();

  MPI::Finalize();
}

Here is the call graph for this function:

Member Function Documentation

BcastCommand()

G4String G4MPImanager::BcastCommand

(

const G4String &

command

)

Definition at line 416 of file G4MPImanager.cc.

{
  enum { kBUFF_SIZE = 512 };
  static char sbuff[kBUFF_SIZE];
  command.copy(sbuff, kBUFF_SIZE);
  G4int len = command.size();
  sbuff[len] ='\0';   // no boundary check

  // "command" is not yet fixed in slaves at this time.

  // waiting message exhausts CPU in LAM!
  //COMM_G4COMMAND_.Bcast(sbuff, ssize, MPI::CHAR, RANK_MASTER);

  // another implementation
  if( is_master_ ) {
    for ( G4int islave = 1; islave < size_; islave++ ) {
      COMM_G4COMMAND_.Send(sbuff, kBUFF_SIZE, MPI::CHAR,
                           islave, kTAG_G4COMMAND);
    }
  } else {
    // try non-blocking receive
    MPI::Request request= COMM_G4COMMAND_.Irecv(sbuff, kBUFF_SIZE, MPI::CHAR,
                                                kRANK_MASTER, kTAG_G4COMMAND);
    // polling...
    while(! request.Test()) {
      ::Wait(1000);
    }
  }

  return G4String(sbuff);
}

BeamOn()

void G4MPImanager::BeamOn	(	G4int	nevent,
		G4bool	qdivide = true
	)

Definition at line 460 of file G4MPImanager.cc.

{
#ifndef G4MULTITHREADED
  G4RunManager* runManager = G4RunManager::GetRunManager();
#endif

  if ( qdivide ) { // events are divided
    G4double ntot = master_weight_ + size_ - 1.;
    G4int nproc = G4int(nevent/ntot);
    G4int nproc0 = nevent - nproc*(size_-1);

    if ( verbose_ > 0 && is_master_ ) {
      G4cout << "#events in master=" << nproc0 << " / "
             << "#events in slave="  << nproc << G4endl;
    }

    status_-> StartTimer(); // start timer

#ifdef G4MULTITHREADED
    G4String str_nevt;
    if ( is_master_ ) str_nevt = G4UIcommand::ConvertToString(nproc0);
    else str_nevt = G4UIcommand::ConvertToString(nproc);
    G4UImanager* UI = G4UImanager::GetUIpointer();
    UI-> ApplyCommand("/run/beamOn " + str_nevt);
#else
    if ( is_master_ ) runManager-> BeamOn(nproc0);
    else runManager-> BeamOn(nproc);
#endif

    status_-> StopTimer(); // stop timer

  } else { // same events are generated in each node (for test use)
    if( verbose_ > 0 && is_master_ ) {
      G4cout << "#events in master=" << nevent << " / "
             << "#events in slave="  << nevent << G4endl;
    }
    status_-> StartTimer(); // start timer

#ifdef G4MULTITHREADED
    G4String str_nevt = G4UIcommand::ConvertToString(nevent);
    G4UImanager* UI = G4UImanager::GetUIpointer();
    UI-> ApplyCommand("/run/beamOn " + str_nevt);
#else
    runManager-> BeamOn(nevent);
#endif

    status_-> StopTimer(); // stop timer
  }
}

Here is the call graph for this function:

CheckThreadStatus()

G4bool G4MPImanager::CheckThreadStatus

(

)

Definition at line 325 of file G4MPImanager.cc.

{
  unsigned buff;
  unsigned qstatus = 0;

  if( is_master_ ) {
    qstatus = (thread_id_ != 0);
    // get slave status
    for ( G4int islave = 1; islave < size_; islave++ ) {
      MPI::Request request = COMM_G4COMMAND_.Irecv(&buff, 1, MPI::UNSIGNED,
                                                  islave, kTAG_G4STATUS);
      while( ! request.Test() ) {
        ::Wait(1000);
      }
      qstatus |= buff;
    }
  } else {
    buff = (thread_id_ !=0);
    COMM_G4COMMAND_.Send(&buff, 1, MPI::UNSIGNED, kRANK_MASTER, kTAG_G4STATUS);
  }

  // broadcast
  buff = qstatus; // for master
  COMM_G4COMMAND_.Bcast(&buff, 1, MPI::UNSIGNED, kRANK_MASTER);
  qstatus = buff; // for slave

  if ( qstatus != 0 ) return true;
  else return false;
}

Here is the caller graph for this function:

DISALLOW_COPY_AND_ASSIGN()

G4MPImanager::DISALLOW_COPY_AND_ASSIGN ( G4MPImanager  )

private

DistributeSeeds()

void G4MPImanager::DistributeSeeds

(

)

Definition at line 287 of file G4MPImanager.cc.

{
  std::vector<G4long> seed_list = seed_generator_-> GetSeedList();
  G4Random::setTheSeed(seed_list[rank_]);
}

Here is the caller graph for this function:

ExecuteBeamOnThread()

void G4MPImanager::ExecuteBeamOnThread

(

const G4String &

command

)

Definition at line 385 of file G4MPImanager.cc.

{
  G4bool threadStatus = CheckThreadStatus();

  if (threadStatus) {
    if ( is_master_ ) {
      G4cout << "G4MPIsession:: beamOn is still running." << G4endl;
    }
  } else { // ok
    static G4String cmdstr;
    cmdstr = command;
    G4int rc = pthread_create(&thread_id_, 0,
                              (Func_t)thread_ExecuteThreadCommand,
                              (void*)&cmdstr);
    if (rc != 0)
      G4Exception("G4MPImanager::ExecuteBeamOnThread()",
                  "MPI003", FatalException,
                  "Failed to create a beamOn thread.");
  }
}

Here is the call graph for this function:

ExecuteMacroFile()

void G4MPImanager::ExecuteMacroFile	(	const G4String &	fname,
		G4bool	qbatch = false
	)

Definition at line 449 of file G4MPImanager.cc.

{
  G4bool currentmode = qbatchmode_;
  qbatchmode_ = true;
  G4MPIbatch* batchSession = new G4MPIbatch(fname, qbatch);
  batchSession-> SessionStart();
  delete batchSession;
  qbatchmode_ = currentmode;
}

ExecuteThreadCommand()

void G4MPImanager::ExecuteThreadCommand

(

const G4String &

command

)

Definition at line 356 of file G4MPImanager.cc.

{
  // this method is a thread function.
  G4UImanager* UI = G4UImanager::GetUIpointer();
  G4int rc = UI-> ApplyCommand(command);

  G4int commandStatus = rc - (rc%100);

  switch( commandStatus ) {
  case fCommandSucceeded:
    break;
  case fIllegalApplicationState:
    G4cerr << "illegal application state -- command refused" << G4endl;
    break;
  default:
    G4cerr << "command refused (" << commandStatus << ")" << G4endl;
    break;
  }

  // thread is joined
  if ( thread_id_ ) {
    pthread_join(thread_id_, 0);
    thread_id_ = 0;
  }

  return;
}

Here is the call graph for this function:

GetInitFileName()

const G4String & G4MPImanager::GetInitFileName ( ) const

inline

Definition at line 203 of file G4MPImanager.hh.

{
  return init_file_name_;

}

Here is the caller graph for this function:

GetMacroFileName()

const G4String & G4MPImanager::GetMacroFileName ( ) const

inline

Definition at line 214 of file G4MPImanager.hh.

{
  return macro_file_name_;
}

Here is the caller graph for this function:

GetManager()

G4MPImanager * G4MPImanager::GetManager ( )

static

Definition at line 103 of file G4MPImanager.cc.

{
  if ( g4mpi_ == NULL ) {
    G4Exception("G4MPImanager::GetManager()", "MPI001",
                FatalException, "G4MPImanager is not instantiated.");
  }
  return g4mpi_;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetMasterWeight()

G4double G4MPImanager::GetMasterWeight ( ) const

inline

Definition at line 227 of file G4MPImanager.hh.

{
  return master_weight_;
}

Here is the caller graph for this function:

GetMPIsession()

G4MPIsession * G4MPImanager::GetMPIsession ( ) const

inline

Definition at line 157 of file G4MPImanager.hh.

{
  return session_;
}

GetRank()

G4int G4MPImanager::GetRank ( ) const

inline

Definition at line 177 of file G4MPImanager.hh.

{
  return rank_;
}

GetSeedGenerator()

G4VMPIseedGenerator * G4MPImanager::GetSeedGenerator ( ) const

inline

Definition at line 232 of file G4MPImanager.hh.

{
  return seed_generator_;
}

GetSize()

G4int G4MPImanager::GetSize ( ) const

inline

Definition at line 182 of file G4MPImanager.hh.

{
  return size_;
}

GetVerbose()

G4int G4MPImanager::GetVerbose ( ) const

inline

Definition at line 162 of file G4MPImanager.hh.

{
  return verbose_;
}

Here is the caller graph for this function:

Initialize()

void G4MPImanager::Initialize ( )

private

Definition at line 113 of file G4MPImanager.cc.

{
  if ( g4mpi_ != NULL ) {
    G4Exception("G4MPImanager::Initialize()", "MPI002",
                FatalException, "G4MPImanager is already instantiated.");
  }

  g4mpi_ = this;

  // get rank information
  size_ = MPI::COMM_WORLD.Get_size();
  rank_ = MPI::COMM_WORLD.Get_rank();
  is_master_ = (rank_ == kRANK_MASTER);
  is_slave_ = (rank_ != kRANK_MASTER);

  // initialize MPI communicator
  COMM_G4COMMAND_ = MPI::COMM_WORLD.Dup();

  // new G4MPI stuffs
  messenger_ = new G4MPImessenger();
  messenger_-> SetTargetObject(this);
  session_ = new G4MPIsession;
  status_ = new G4MPIstatus;

  // default seed generator is random generator.
  seed_generator_ = new G4MPIrandomSeedGenerator;
  DistributeSeeds();
}

Here is the call graph for this function:

Here is the caller graph for this function:

IsBatchMode()

G4bool G4MPImanager::IsBatchMode ( ) const

inline

Definition at line 209 of file G4MPImanager.hh.

{
  return qbatchmode_;
}

IsInitMacro()

G4bool G4MPImanager::IsInitMacro ( ) const

inline

Definition at line 197 of file G4MPImanager.hh.

{
  return qinitmacro_;

}

IsMaster()

G4bool G4MPImanager::IsMaster ( ) const

inline

Definition at line 187 of file G4MPImanager.hh.

{
  return is_master_;
}

IsSlave()

G4bool G4MPImanager::IsSlave ( ) const

inline

Definition at line 192 of file G4MPImanager.hh.

{
  return is_slave_;
}

JoinBeamOnThread()

void G4MPImanager::JoinBeamOnThread

(

)

Definition at line 407 of file G4MPImanager.cc.

{
  if ( thread_id_ ) {
    pthread_join(thread_id_, 0);
    thread_id_ = 0;
  }
}

ParseArguments()

void G4MPImanager::ParseArguments ( G4int  argc, char **  argv  )

private

Definition at line 143 of file G4MPImanager.cc.

{
  G4int qhelp = 0;
  G4String ofprefix = "mpi";

  G4int c;
  while ( 1 ) {
    G4int option_index = 0;
    static struct option long_options[] = {
      {"help",    no_argument,        NULL, 'h'},
      {"verbose", no_argument,        NULL, 'v'},
      {"init",    required_argument,  NULL, 'i'},
      {"ofile",   optional_argument,  NULL, 'o'},
      {NULL,      0,                  NULL,  0}
    };

    opterr = 0; // suppress message
    c = getopt_long(argc, argv, "hvi:o", long_options, &option_index);
    opterr = 1;

    if( c == -1 ) break;

    switch (c) {
    case 'h' :
      qhelp = 1;
      break;
    case 'v' :
      verbose_ = 1;
      break;
    case 'i' :
      qinitmacro_ = true;
      init_file_name_ = optarg;
      break;
    case 'o' :
      qfcout_ = true;
      if ( optarg ) ofprefix = optarg;
      break;
    default:
      G4cerr << "*** invalid options specified." << G4endl;
      std::exit(EXIT_FAILURE);
      break;
    }
  }

  // show help
  if ( qhelp ) {
    if ( is_master_ ) ShowHelp();
    MPI::Finalize();
    std::exit(EXIT_SUCCESS);
  }

  // file output
  if( is_slave_ && qfcout_ ) {
    G4String prefix = ofprefix + ".%03d" + ".cout";
    char str[1024];
    sprintf(str, prefix.c_str(), rank_);
    G4String fname(str);
    fscout_.open(fname.c_str(), std::ios::out);
  }

  // non-option ARGV-elements ...
  if ( optind < argc ) {
    qbatchmode_ = true;
    macro_file_name_ = argv[optind];
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Print()

void G4MPImanager::Print

(

const G4String &

message

)

Definition at line 532 of file G4MPImanager.cc.

{
  if ( is_master_ ){
    std::cout << message << std::flush;
  } else {
    if ( qfcout_ ) { // output to a file
      fscout_ << message << std::flush;
    } else { // output to stdout
      std::cout << rank_ << ":" << message << std::flush;
    }
  }
}

Here is the caller graph for this function:

SetMasterWeight()

void G4MPImanager::SetMasterWeight ( G4double  aweight )

inline

Definition at line 219 of file G4MPImanager.hh.

{
  master_weight_ = aweight;

  if( aweight < 0. ) master_weight_ = 0.;
  if( aweight > 1. ) master_weight_ = 1.;
}

SetSeed()

void G4MPImanager::SetSeed	(	G4int	inode,
		G4long	seed
	)

Definition at line 317 of file G4MPImanager.cc.

{
  if( rank_ == inode ) {
    CLHEP::HepRandom::setTheSeed(seed);
  }
}

Here is the call graph for this function:

SetVerbose()

void G4MPImanager::SetVerbose ( G4int  iverbose )

inline

Definition at line 167 of file G4MPImanager.hh.

{
  G4int lv = iverbose;
  if( iverbose > 1 ) lv = 1;
  if( iverbose < 0 ) lv = 0;

  verbose_ = lv;
  return;
}

ShowHelp()

void G4MPImanager::ShowHelp

(

)

const

Definition at line 546 of file G4MPImanager.cc.

{
  if (is_slave_ ) return;

  G4cout << "Geant4 MPI interface" << G4endl;
  G4cout << "usage:" << G4endl;
  G4cout << "<app> [options] [macro file]"
         << G4endl << G4endl;
  G4cout << "   -h, --help              show this message."
         << G4endl;
  G4cout << "   -v, --verbose           show verbose message"
         << G4endl;
  G4cout << "   -i, --init=FNAME        set an init macro file"
         << G4endl;
  G4cout << "   -o, --ofile[=FNAME]     set slave output to a flie"
         << G4endl;
  G4cout << G4endl;
}

Here is the caller graph for this function:

ShowSeeds()

void G4MPImanager::ShowSeeds

(

)

Definition at line 294 of file G4MPImanager.cc.

{
  G4long buff;

  if ( is_master_ ) {
    // print master
    G4cout << "* rank= " << rank_
           << " seed= " << G4Random::getTheSeed()
           << G4endl;
    // receive from each slave
    for ( G4int islave = 1; islave < size_; islave++ ) {
      COMM_G4COMMAND_.Recv(&buff, 1, MPI::LONG, islave, kTAG_G4SEED);
      G4cout << "* rank= " << islave
             << " seed= " << buff
             << G4endl;
    }
  } else { // slaves
    buff = G4Random::getTheSeed();
    COMM_G4COMMAND_.Send(&buff, 1, MPI::LONG, kRANK_MASTER, kTAG_G4SEED);
  }
}

ShowStatus()

void G4MPImanager::ShowStatus

(

)

Definition at line 238 of file G4MPImanager.cc.

{
  G4int buff[G4MPIstatus::kNSIZE];

  UpdateStatus();
  G4bool gstatus = CheckThreadStatus();

  if ( is_master_ ) {
    status_-> Print();  // for maser itself

    G4int nev = status_-> GetEventID();
    G4int nevtp = status_-> GetNEventToBeProcessed();
    G4double cputime = status_-> GetCPUTime();

    // receive from each slave
    for ( G4int islave = 1; islave < size_; islave++ ) {
      COMM_G4COMMAND_.Recv(buff, G4MPIstatus::kNSIZE, MPI::INT,
                          islave, kTAG_G4STATUS);
      status_-> UnPack(buff);
      status_-> Print();

      // aggregation
      nev += status_-> GetEventID();
      nevtp += status_-> GetNEventToBeProcessed();
      cputime += status_-> GetCPUTime();
    }

    G4String strStatus;
    if ( gstatus ) {
      strStatus = "Run";
    } else {
      strStatus = "Idle";
    }

    G4cout << "-------------------------------------------------------"
           << G4endl
           << "* #ranks= " << size_
           << "   event= " << nev << "/" << nevtp
           << " state= " << strStatus
           << " time= " << cputime << "s"
           << G4endl;
  } else {
    status_-> Pack(buff);
    COMM_G4COMMAND_.Send(buff, G4MPIstatus::kNSIZE, MPI::INT,
                         kRANK_MASTER, kTAG_G4STATUS);
  }
}

Here is the call graph for this function:

UpdateStatus()

void G4MPImanager::UpdateStatus ( )

private

Definition at line 211 of file G4MPImanager.cc.

{
  G4RunManager* runManager = G4RunManager::GetRunManager();
  const G4Run* run = runManager-> GetCurrentRun();

  G4int runid, eventid, neventTBP;

  G4StateManager* stateManager = G4StateManager::GetStateManager();
  G4ApplicationState g4state = stateManager-> GetCurrentState();

  if ( run ) {
    runid = run-> GetRunID();
    neventTBP = run -> GetNumberOfEventToBeProcessed();
    eventid = run-> GetNumberOfEvent();
    if( g4state == G4State_GeomClosed || g4state == G4State_EventProc ) {
      status_-> StopTimer();
    }
  } else {
    runid = 0;
    eventid = 0;
    neventTBP = 0;
  }

  status_-> SetStatus(rank_, runid, neventTBP, eventid, g4state);
}

Here is the call graph for this function:

Here is the caller graph for this function:

WaitBeamOn()

void G4MPImanager::WaitBeamOn

(

)

Definition at line 511 of file G4MPImanager.cc.

{
  G4int buff = 0;
  if ( qbatchmode_ ) {  // valid only in batch mode
    if ( is_master_ ) {
      // receive from each slave
      for (G4int islave = 1; islave < size_; islave++) {
        MPI::Request request = COMM_G4COMMAND_.Irecv(&buff, 1, MPI::INT,
                                                     islave, kTAG_G4STATUS);
        while(! request.Test()) {
           ::Wait(1000);
        }
      }
    } else {
      buff = 1;
      COMM_G4COMMAND_.Send(&buff, 1, MPI::INT, kRANK_MASTER, kTAG_G4STATUS);
    }
  }
}

Member Data Documentation

COMM_G4COMMAND_

MPI::Intracomm G4MPImanager::COMM_G4COMMAND_

private

Definition at line 137 of file G4MPImanager.hh.

fscout_

std::ofstream G4MPImanager::fscout_

private

Definition at line 141 of file G4MPImanager.hh.

g4mpi_

G4MPImanager * G4MPImanager::g4mpi_ = NULL

staticprivate

Definition at line 119 of file G4MPImanager.hh.

init_file_name_

G4String G4MPImanager::init_file_name_

private

Definition at line 145 of file G4MPImanager.hh.

is_master_

G4bool G4MPImanager::is_master_

private

Definition at line 131 of file G4MPImanager.hh.

is_slave_

G4bool G4MPImanager::is_slave_

private

Definition at line 132 of file G4MPImanager.hh.

macro_file_name_

G4String G4MPImanager::macro_file_name_

private

Definition at line 147 of file G4MPImanager.hh.

master_weight_

G4double G4MPImanager::master_weight_

private

Definition at line 153 of file G4MPImanager.hh.

messenger_

G4MPImessenger* G4MPImanager::messenger_

private

Definition at line 120 of file G4MPImanager.hh.

qbatchmode_

G4bool G4MPImanager::qbatchmode_

private

Definition at line 146 of file G4MPImanager.hh.

qfcout_

G4bool G4MPImanager::qfcout_

private

Definition at line 140 of file G4MPImanager.hh.

qinitmacro_

G4bool G4MPImanager::qinitmacro_

private

Definition at line 144 of file G4MPImanager.hh.

rank_

G4int G4MPImanager::rank_

private

Definition at line 133 of file G4MPImanager.hh.

seed_generator_

G4VMPIseedGenerator* G4MPImanager::seed_generator_

private

Definition at line 124 of file G4MPImanager.hh.

session_

G4MPIsession* G4MPImanager::session_

private

Definition at line 121 of file G4MPImanager.hh.

size_

G4int G4MPImanager::size_

private

Definition at line 134 of file G4MPImanager.hh.

status_

G4MPIstatus* G4MPImanager::status_

private

Definition at line 126 of file G4MPImanager.hh.

thread_id_

pthread_t G4MPImanager::thread_id_

private

Definition at line 150 of file G4MPImanager.hh.

verbose_

G4int G4MPImanager::verbose_

private

Definition at line 128 of file G4MPImanager.hh.

---

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

• G4MPImanager.hh
• G4MPImanager.cc