G4VScoreWriter Class Reference

#include <G4VScoreWriter.hh>

Public Member Functions
	G4VScoreWriter ()=default
virtual	~G4VScoreWriter ()=default
virtual void	DumpQuantityToFile (const G4String &psName, const G4String &fileName, const G4String &option)
virtual void	DumpAllQuantitiesToFile (const G4String &fileName, const G4String &option)
void	SetScoringMesh (G4VScoringMesh *sm)
void	SetVerboseLevel (G4int vl)
void	SetFactor (G4double val=1.0)
G4double	GetFactor () const

Protected Member Functions
G4int	GetIndex (G4int x, G4int y, G4int z) const

Protected Attributes
G4int	fNMeshSegments [3] = {0, 0, 0}
G4VScoringMesh *	fScoringMesh = nullptr
G4int	verboseLevel = 0
G4double	fact = 1.0

Detailed Description

Definition at line 40 of file G4VScoreWriter.hh.

Constructor & Destructor Documentation

G4VScoreWriter()

G4VScoreWriter::G4VScoreWriter ( )

default

~G4VScoreWriter()

virtual G4VScoreWriter::~G4VScoreWriter ( )

virtualdefault

Member Function Documentation

DumpAllQuantitiesToFile()

void G4VScoreWriter::DumpAllQuantitiesToFile ( const G4String & fileName, const G4String & option )

virtual

Definition at line 159 of file G4VScoreWriter.cc.

{
  // change the option string into lowercase to the case-insensitive.
  G4String opt = option;
  std::transform(opt.begin(), opt.end(), opt.begin(), (int (*)(int))(tolower));
 
  // confirm the option
  if(opt.empty())
    opt = "csv";
  if(opt.find("csv") == std::string::npos &&
     opt.find("sequence") == std::string::npos)
  {
    G4cerr << "ERROR : DumpToFile : Unknown option -> " << option << G4endl;
    return;
  }
 
  // open the file
  std::ofstream ofile(fileName);
  if(!ofile)
  {
    G4cerr << "ERROR : DumpToFile : File open error -> " << fileName << G4endl;
    return;
  }
  ofile << "# mesh name: " << fScoringMesh->GetWorldName() << G4endl;
  if(fact != 1.0)
  {
    ofile << "# multiplied factor : " << fact << std::endl;
  }
 
  // retrieve the map
  using MeshScoreMap = G4VScoringMesh::MeshScoreMap;
  MeshScoreMap fSMap = fScoringMesh->GetScoreMap();
  // NOLINTNEXTLINE(modernize-use-auto): Explicitly want a const_iterator 
  MeshScoreMap::const_iterator msMapItr = fSMap.begin();
  std::map<G4int, G4StatDouble*>* score;
  for(; msMapItr != fSMap.end(); msMapItr++)
  {
    G4String psname = msMapItr->first;
 
    score = msMapItr->second->GetMap();
    ofile << "# primitive scorer name: " << msMapItr->first << std::endl;
 
    G4double unitValue = fScoringMesh->GetPSUnitValue(psname);
    G4String unit      = fScoringMesh->GetPSUnit(psname);
    G4String divisionAxisNames[3];
    fScoringMesh->GetDivisionAxisNames(divisionAxisNames);
    // index order
    ofile << "# i" << divisionAxisNames[0] << ", i" << divisionAxisNames[1]
          << ", i" << divisionAxisNames[2];
    // unit of scored value
    ofile << ", total(value) ";
    if(!unit.empty())
      ofile << "[" << unit << "]";
    ofile << ", total(val^2), entry" << G4endl;
 
    // "sequence" option: write header info
    if(opt.find("sequence") != std::string::npos)
    {
      ofile << fNMeshSegments[0] << " " << fNMeshSegments[1] << " "
            << fNMeshSegments[2] << G4endl;
    }
 
    // write quantity
    long count = 0;
    ofile << std::setprecision(16);  // for double value with 8 bytes
    for(int x = 0; x < fNMeshSegments[0]; x++)
    {
      for(int y = 0; y < fNMeshSegments[1]; y++)
      {
        for(int z = 0; z < fNMeshSegments[2]; z++)
        {
          G4int idx = GetIndex(x, y, z);
 
          if(opt.find("csv") != std::string::npos)
            ofile << x << "," << y << "," << z << ",";
 
          auto value = score->find(idx);
          if(value == score->end())
          {
            ofile << 0. << "," << 0. << "," << 0;
          }
          else
          {
            ofile << (value->second->sum_wx()) / unitValue * fact << ","
                  << (value->second->sum_wx2()) / unitValue / unitValue * fact *
                       fact
                  << "," << value->second->n();
          }
 
          if(opt.find("csv") != std::string::npos)
          {
            ofile << G4endl;
          }
          else if(opt.find("sequence") != std::string::npos)
          {
            ofile << " ";
            if(count++ % 5 == 4)
              ofile << G4endl;
          }
 
        }  // z
      }    // y
    }      // x
    ofile << std::setprecision(6);
 
  }  // for(; msMapItr ....)
 
  // close the file
  ofile.close();
}

Referenced by G4ScoringManager::DumpAllQuantitiesToFile().

DumpQuantityToFile()

void G4VScoreWriter::DumpQuantityToFile ( const G4String & psName, const G4String & fileName, const G4String & option )

virtual

Definition at line 45 of file G4VScoreWriter.cc.

{
  // change the option string into lowercase to the case-insensitive.
  G4String opt = option;
  std::transform(opt.begin(), opt.end(), opt.begin(), (int (*)(int))(tolower));
 
  // confirm the option
  if(opt.empty())
    opt = "csv";
  if(opt.find("csv") == std::string::npos &&
     opt.find("sequence") == std::string::npos)
  {
    G4cerr << "ERROR : DumpToFile : Unknown option -> " << option << G4endl;
    return;
  }
 
  // open the file
  std::ofstream ofile(fileName);
  if(!ofile)
  {
    G4cerr << "ERROR : DumpToFile : File open error -> " << fileName << G4endl;
    return;
  }
  ofile << "# mesh name: " << fScoringMesh->GetWorldName() << G4endl;
 
  using MeshScoreMap = G4VScoringMesh::MeshScoreMap;
  // retrieve the map
  MeshScoreMap fSMap = fScoringMesh->GetScoreMap();
 
  // NOLINTNEXTLINE(modernize-use-auto): Explicitly want a const_iterator 
  MeshScoreMap::const_iterator msMapItr = fSMap.find(psName);
  if(msMapItr == fSMap.end())
  {
    G4cerr << "ERROR : DumpToFile : Unknown quantity, \"" << psName << "\"."
           << G4endl;
    return;
  }
 
  std::map<G4int, G4StatDouble*>* score = msMapItr->second->GetMap();
  ofile << "# primitive scorer name: " << msMapItr->first << std::endl;
  if(fact != 1.0)
  {
    ofile << "# multiplied factor : " << fact << std::endl;
  }
 
  G4double unitValue = fScoringMesh->GetPSUnitValue(psName);
  G4String unit      = fScoringMesh->GetPSUnit(psName);
  G4String divisionAxisNames[3];
  fScoringMesh->GetDivisionAxisNames(divisionAxisNames);
  // index order
  ofile << "# i" << divisionAxisNames[0] << ", i" << divisionAxisNames[1]
        << ", i" << divisionAxisNames[2];
  // unit of scored value
  ofile << ", total(value) ";
  if(!unit.empty())
    ofile << "[" << unit << "]";
  ofile << ", total(val^2), entry" << G4endl;
 
  // "sequence" option: write header info
  if(opt.find("sequence") != std::string::npos)
  {
    ofile << fNMeshSegments[0] << " " << fNMeshSegments[1] << " "
          << fNMeshSegments[2] << G4endl;
  }
 
  // write quantity
  long count = 0;
  ofile << std::setprecision(16);  // for double value with 8 bytes
  for(int x = 0; x < fNMeshSegments[0]; x++)
  {
    for(int y = 0; y < fNMeshSegments[1]; y++)
    {
      for(int z = 0; z < fNMeshSegments[2]; z++)
      {
        G4int idx = GetIndex(x, y, z);
 
        if(opt.find("csv") != std::string::npos)
          ofile << x << "," << y << "," << z << ",";
 
        auto value = score->find(idx);
        if(value == score->end())
        {
          ofile << 0. << "," << 0. << "," << 0;
        }
        else
        {
          ofile << (value->second->sum_wx()) / unitValue * fact << ","
                << (value->second->sum_wx2()) / unitValue / unitValue * fact *
                     fact
                << "," << value->second->n();
        }
 
        if(opt.find("csv") != std::string::npos)
        {
          ofile << G4endl;
        }
        else if(opt.find("sequence") != std::string::npos)
        {
          ofile << " ";
          if(count++ % 5 == 4)
            ofile << G4endl;
        }
 
      }  // z
    }    // y
  }      // x
  ofile << std::setprecision(6);
 
  // close the file
  ofile.close();
}

Referenced by G4ScoringManager::DumpQuantityToFile().

GetFactor()

G4double G4VScoreWriter::GetFactor ( ) const

inline

Definition at line 60 of file G4VScoreWriter.hh.

{ return fact; }

Referenced by G4ScoringManager::GetFactor().

GetIndex()

G4int G4VScoreWriter::GetIndex ( G4int x, G4int y, G4int z ) const

protected

Definition at line 271 of file G4VScoreWriter.cc.

{
  return x * fNMeshSegments[1] * fNMeshSegments[2] + y * fNMeshSegments[2] + z;
}

Referenced by DumpAllQuantitiesToFile(), and DumpQuantityToFile().

SetFactor()

void G4VScoreWriter::SetFactor ( G4double val = 1.0 )

inline

Definition at line 59 of file G4VScoreWriter.hh.

{ fact = val; }

Referenced by G4ScoringManager::SetFactor().

SetScoringMesh()

void G4VScoreWriter::SetScoringMesh

(

G4VScoringMesh *

sm

)

Definition at line 38 of file G4VScoreWriter.cc.

{
  // Should be checked for nullptr!
  fScoringMesh = sm;
  fScoringMesh->GetNumberOfSegments(fNMeshSegments);
}

Referenced by G4ScoringManager::DumpAllQuantitiesToFile(), and G4ScoringManager::DumpQuantityToFile().

SetVerboseLevel()

void G4VScoreWriter::SetVerboseLevel ( G4int vl )

inline

Definition at line 58 of file G4VScoreWriter.hh.

{ verboseLevel = vl; }

Referenced by G4ScoringManager::SetScoreWriter(), and G4ScoringManager::SetVerboseLevel().

Member Data Documentation

fact

G4double G4VScoreWriter::fact = 1.0

protected

Definition at line 70 of file G4VScoreWriter.hh.

Referenced by DumpAllQuantitiesToFile(), DumpQuantityToFile(), GetFactor(), and SetFactor().

fNMeshSegments

G4int G4VScoreWriter::fNMeshSegments[3] = {0, 0, 0}

protected

Definition at line 67 of file G4VScoreWriter.hh.

{0, 0, 0};  // number of segments of the mesh

Referenced by DumpAllQuantitiesToFile(), DumpQuantityToFile(), GetIndex(), and SetScoringMesh().

fScoringMesh

G4VScoringMesh* G4VScoreWriter::fScoringMesh = nullptr

protected

Definition at line 68 of file G4VScoreWriter.hh.

Referenced by DumpAllQuantitiesToFile(), DumpQuantityToFile(), and SetScoringMesh().

verboseLevel

G4int G4VScoreWriter::verboseLevel = 0

protected

Definition at line 69 of file G4VScoreWriter.hh.

Referenced by SetVerboseLevel().

---

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

• G4VScoreWriter.hh
• G4VScoreWriter.cc