G4MTcoutDestination Class Reference

#include <G4MTcoutDestination.hh>

Inheritance diagram for G4MTcoutDestination:

Public Member Functions
	G4MTcoutDestination (const G4int &threadId)
virtual	~G4MTcoutDestination ()
virtual void	Reset ()
void	SetDefaultOutput (G4bool addMasterDestination=true, G4bool formatAlsoMaster=true)
void	SetCoutFileName (const G4String &fileN="G4cout.txt", G4bool ifAppend=true)
void	AddCoutFileName (const G4String &fileN="G4cout.txt", G4bool ifAppend=true)
void	SetCerrFileName (const G4String &fileN="G4cerr.txt", G4bool ifAppend=true)
void	AddCerrFileName (const G4String &fileN="G4cerr.txt", G4bool ifAppend=true)
void	EnableBuffering (G4bool flag=true)
void	SetPrefixString (const G4String &wd="G4WT")
void	SetIgnoreCout (G4int tid=0)
void	SetIgnoreInit (G4bool val=true)
G4String	GetPrefixString () const
G4String	GetFullPrefixString () const
Public Member Functions inherited from G4MulticoutDestination
	G4MulticoutDestination ()=default
virtual	~G4MulticoutDestination ()
virtual G4int	ReceiveG4cout (const G4String &msg) override
virtual G4int	ReceiveG4cerr (const G4String &msg) override
Public Member Functions inherited from G4coutDestination
	G4coutDestination ()=default
virtual	~G4coutDestination ()
void	AddCoutTransformer (const Transformer &t)
void	AddCoutTransformer (Transformer &&t)
void	AddCerrTransformer (const Transformer &t)
void	AddCerrTransformer (Transformer &&t)
virtual void	ResetTransformers ()
virtual G4int	ReceiveG4cout (const G4String &msg)
virtual G4int	ReceiveG4cerr (const G4String &msg)
G4int	ReceiveG4cout_ (const G4String &msg)
G4int	ReceiveG4cerr_ (const G4String &msg)

Protected Member Functions
void	AddMasterOutput (G4bool formatAlsoMaster)
void	HandleFileCout (G4String fileN, G4bool appendFlag, G4bool suppressDefault)
void	HandleFileCerr (G4String fileN, G4bool appendFlag, G4bool suppressDefault)

Additional Inherited Members
Public Types inherited from G4coutDestination
using	Transformer = std::function< G4bool(G4String &)>
Protected Attributes inherited from G4coutDestination
std::vector< Transformer >	transformersCout
std::vector< Transformer >	transformersCerr
Static Protected Attributes inherited from G4coutDestination
static G4MTGLOB_DLL G4coutDestination *	masterG4coutDestination = nullptr

Detailed Description

Definition at line 45 of file G4MTcoutDestination.hh.

Constructor & Destructor Documentation

G4MTcoutDestination()

G4MTcoutDestination::G4MTcoutDestination ( const G4int &  threadId )

explicit

Definition at line 48 of file G4MTcoutDestination.cc.

  : id(threadId)
{
  // TODO: Move these two out of here and in the caller
  G4coutbuf.SetDestination(this);
  G4cerrbuf.SetDestination(this);
 
  stateMgr = G4StateManager::GetStateManager();
  SetDefaultOutput(masterDestinationFlag, masterDestinationFmtFlag);
}

~G4MTcoutDestination()

G4MTcoutDestination::~G4MTcoutDestination ( )

virtual

Definition at line 132 of file G4MTcoutDestination.cc.

{
  if(useBuffer)
    DumpBuffer();
}

Member Function Documentation

AddCerrFileName()

void G4MTcoutDestination::AddCerrFileName	(	const G4String &	fileN = "G4cerr.txt",
		G4bool	ifAppend = true
	)

Definition at line 254 of file G4MTcoutDestination.cc.

{
  HandleFileCerr(fileN, ifAppend, false);
}

AddCoutFileName()

void G4MTcoutDestination::AddCoutFileName	(	const G4String &	fileN = "G4cout.txt",
		G4bool	ifAppend = true
	)

Definition at line 233 of file G4MTcoutDestination.cc.

{
  // This is like the equivalent SetCoutFileName, but in this case we do not
  // remove or silence what is already exisiting
  HandleFileCout(fileN, ifAppend, false);
}

AddMasterOutput()

void G4MTcoutDestination::AddMasterOutput ( G4bool  formatAlsoMaster )

protected

Definition at line 99 of file G4MTcoutDestination.cc.

{
  // Add a destination, that forwards the message to the master thread
  auto forwarder = G4coutDestinationUPtr(new G4MasterForwardcoutDestination);
  ref_masterOut  = forwarder.get();
  const auto filter_out = [this](G4String&) -> G4bool {
    if(this->ignoreCout ||
       (this->ignoreInit && this->stateMgr->GetCurrentState() == G4State_Idle))
    {
      return false;
    }
    return true;
  };
  forwarder->AddCoutTransformer(filter_out);
  if(formatAlsoMaster)
  {
    // Formatter: add prefix to each thread
    const auto f = [this](G4String& msg) -> G4bool {
      std::ostringstream str;
      str << prefix;
      if(id != G4Threading::GENERICTHREAD_ID)
        str << id;
      str << " > " << msg;
      msg = str.str();
      return true;
    };
    forwarder->AddCoutTransformer(f);
    forwarder->AddCerrTransformer(f);
  }
  push_back(std::move(forwarder));
}

Referenced by SetDefaultOutput().

EnableBuffering()

void G4MTcoutDestination::EnableBuffering

(

G4bool

flag = true

)

Definition at line 202 of file G4MTcoutDestination.cc.

{
  // I was using buffered output and now I want to turn it off, dump current
  // buffer content and reset output
  if(useBuffer && !flag)
  {
    DumpBuffer();
    Reset();
  }
  else if(useBuffer && flag)
  { /* do nothing: already using */
  }
  else if(!useBuffer && !flag)
  { /* do nothing: not using */
  }
  else if(!useBuffer && flag)
  {
    // Remove everything, in this case also removing the forward to the master
    // thread, we want everything to be dumpled to a file
    clear();
    const size_t infiniteSize = 0;
    push_back(G4coutDestinationUPtr(new G4BuffercoutDestination(infiniteSize)));
  }
  else  // Should never happen
  {
    assert(false);
  }
  useBuffer = flag;
}

Referenced by G4UImanager::SetThreadUseBuffer().

GetFullPrefixString()

G4String G4MTcoutDestination::GetFullPrefixString ( ) const

inline

Definition at line 73 of file G4MTcoutDestination.hh.

  {
    std::stringstream os;
    os << prefix << id;
    return os.str();
  }

GetPrefixString()

G4String G4MTcoutDestination::GetPrefixString ( ) const

inline

Definition at line 72 of file G4MTcoutDestination.hh.

{ return prefix; }

HandleFileCerr()

void G4MTcoutDestination::HandleFileCerr ( G4String  fileN, G4bool  appendFlag, G4bool  suppressDefault  )

protected

Definition at line 171 of file G4MTcoutDestination.cc.

{
  // See HandleFileCout for explanation, switching cout with cerr
 
  std::ios_base::openmode mode =
    (ifAppend ? std::ios_base::app : std::ios_base::trunc);
  auto output = G4coutDestinationUPtr(new G4FilecoutDestination(fileN, mode));
  output->AddCoutTransformer([](G4String&) { return false; });
  push_back(std::move(output));
  if(suppressDefault)
  {
    ref_defaultOut->AddCerrTransformer([](G4String&) { return false; });
    if(ref_masterOut)
      ref_masterOut->AddCerrTransformer([](G4String&) { return false; });
  }
}

Referenced by AddCerrFileName(), and SetCerrFileName().

HandleFileCout()

void G4MTcoutDestination::HandleFileCout ( G4String  fileN, G4bool  appendFlag, G4bool  suppressDefault  )

protected

Definition at line 146 of file G4MTcoutDestination.cc.

{
  // Logic: we create a file destination. We want this to get only the G4cout
  // stream and should discard everything in G4cerr.
  // First we create the destination with the appropriate open mode
 
  std::ios_base::openmode mode =
    (ifAppend ? std::ios_base::app : std::ios_base::trunc);
  auto output = G4coutDestinationUPtr(new G4FilecoutDestination(fileN, mode));
 
  // This reacts only to G4cout, so let's make a filter that removes everything
  // from G4cerr
  output->AddCerrTransformer([](G4String&) { return false; });
  push_back(std::move(output));
  // Silence G4cout from default formatter
  if(suppressDefault)
  {
    ref_defaultOut->AddCoutTransformer([](G4String&) { return false; });
    if(ref_masterOut)
      ref_masterOut->AddCoutTransformer([](G4String&) { return false; });
  }
}

Referenced by AddCoutFileName(), and SetCoutFileName().

Reset()

void G4MTcoutDestination::Reset ( )

virtual

Definition at line 139 of file G4MTcoutDestination.cc.

{
  clear();
  SetDefaultOutput(masterDestinationFlag, masterDestinationFmtFlag);
}

Referenced by EnableBuffering(), SetCerrFileName(), and SetCoutFileName().

SetCerrFileName()

void G4MTcoutDestination::SetCerrFileName	(	const G4String &	fileN = "G4cerr.txt",
		G4bool	ifAppend = true
	)

Definition at line 242 of file G4MTcoutDestination.cc.

{
  // See SetCoutFileName for explanation
  Reset();
  if(fileN != "**Screen**")
  {
    HandleFileCerr(fileN, ifAppend, true);
  }
}

Referenced by G4UImanager::SetCerrFileName().

SetCoutFileName()

void G4MTcoutDestination::SetCoutFileName	(	const G4String &	fileN = "G4cout.txt",
		G4bool	ifAppend = true
	)

Definition at line 190 of file G4MTcoutDestination.cc.

{
  // First let's go back to the default
  Reset();
  if(fileN != "**Screen**")
  {
    HandleFileCout(fileN, ifAppend, true);
  }
}

Referenced by G4UImanager::SetCoutFileName().

SetDefaultOutput()

void G4MTcoutDestination::SetDefaultOutput	(	G4bool	addMasterDestination = true,
		G4bool	formatAlsoMaster = true
	)

Definition at line 60 of file G4MTcoutDestination.cc.

{
  masterDestinationFlag    = addmasterDestination;
  masterDestinationFmtFlag = formatAlsoMaster;
  // Formatter: add prefix to each thread
  const auto f = [this](G4String& msg) -> G4bool {
    std::ostringstream str;
    str << prefix;
    if(id != G4Threading::GENERICTHREAD_ID)
      str << id;
    str << " > " << msg;
    msg = str.str();
    return true;
  };
  // Block cout if not in correct state
  const auto filter_out = [this](G4String&) -> G4bool {
    if(this->ignoreCout ||
       (this->ignoreInit && this->stateMgr->GetCurrentState() == G4State_Init))
    {
      return false;
    }
    return true;
  };
 
  // Default behavior, add a destination that uses cout and uses a mutex
  auto output    = G4coutDestinationUPtr(new G4LockcoutDestination);
  ref_defaultOut = output.get();
  output->AddCoutTransformer(filter_out);
  output->AddCoutTransformer(f);
  output->AddCerrTransformer(f);
  push_back(std::move(output));
  if(addmasterDestination)
  {
    AddMasterOutput(formatAlsoMaster);
  }
}

Referenced by G4MTcoutDestination(), and Reset().

SetIgnoreCout()

void G4MTcoutDestination::SetIgnoreCout

(

G4int

tid = 0

)

Definition at line 261 of file G4MTcoutDestination.cc.

{
  if(tid < 0)
  {
    ignoreCout = false;
  }
  else
  {
    ignoreCout = (tid != id);
  }
}

Referenced by G4UImanager::SetThreadIgnore(), G4UImanager::SetUpForAThread(), and G4UImanager::SetUpForSpecialThread().

SetIgnoreInit()

void G4MTcoutDestination::SetIgnoreInit ( G4bool  val = true )

inline

Definition at line 70 of file G4MTcoutDestination.hh.

{ ignoreInit = val; }

Referenced by G4UImanager::SetThreadIgnoreInit().

SetPrefixString()

void G4MTcoutDestination::SetPrefixString ( const G4String &  wd = "G4WT" )

inline

Definition at line 67 of file G4MTcoutDestination.hh.

{ prefix = wd; }

Referenced by G4UImanager::SetThreadPrefixString(), and G4UImanager::SetUpForSpecialThread().

---

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

• G4MTcoutDestination.hh
• G4MTcoutDestination.cc