G4VScoreWriter Class Reference

#include <G4VScoreWriter.hh>

Inheritance diagram for G4VScoreWriter:

Public Member Functions
	G4VScoreWriter ()
virtual	~G4VScoreWriter ()
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)

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

Protected Attributes
G4int	fNMeshSegments [3]
G4VScoringMesh *	fScoringMesh
G4int	verboseLevel

Detailed Description

Definition at line 41 of file G4VScoreWriter.hh.

Constructor & Destructor Documentation

G4VScoreWriter::G4VScoreWriter

(

)

Definition at line 40 of file G4VScoreWriter.cc.

References fNMeshSegments.

  : fScoringMesh(0), verboseLevel(0) {
  fNMeshSegments[0] = fNMeshSegments[1] = fNMeshSegments[2] = 0;
}

G4VScoreWriter::~G4VScoreWriter ( )

virtual

Definition at line 45 of file G4VScoreWriter.cc.

                                {
}

Member Function Documentation

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

virtual

Definition at line 150 of file G4VScoreWriter.cc.

References G4String::first(), fNMeshSegments, fScoringMesh, G4cerr, G4endl, G4VScoringMesh::GetDivisionAxisNames(), GetIndex(), G4VScoringMesh::GetPSUnit(), G4VScoringMesh::GetPSUnitValue(), G4VScoringMesh::GetScoreMap(), G4VScoringMesh::GetWorldName(), int(), ofile, test::x, and z.

Referenced by G4ScoringManager::DumpAllQuantitiesToFile().

                                                                     {

  // 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.size() == 0) 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;

  // retrieve the map
  MeshScoreMap fSMap = fScoringMesh->GetScoreMap();
  MeshScoreMap::const_iterator msMapItr = fSMap.begin();
  std::map<G4int, G4double*> * 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 << ", value ";
    if(unit.size() > 0) ofile << "[" << unit << "]";
    ofile << 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 << ",";
      
      std::map<G4int, G4double*>::iterator value = score->find(idx);
      if(value == score->end()) {
        ofile << 0.;
      } else {
        ofile << *(value->second)/unitValue;
      }

      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();
  
}

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

virtual

Reimplemented in BrachyUserScoreWriter, and RE03UserScoreWriter.

Definition at line 53 of file G4VScoreWriter.cc.

References fNMeshSegments, fScoringMesh, G4cerr, G4endl, G4VScoringMesh::GetDivisionAxisNames(), GetIndex(), G4VScoringMesh::GetPSUnit(), G4VScoringMesh::GetPSUnitValue(), G4VScoringMesh::GetScoreMap(), G4VScoringMesh::GetWorldName(), int(), ofile, test::x, and z.

Referenced by G4ScoringManager::DumpQuantityToFile().

                                                                {

  // 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.size() == 0) 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;

  
  // retrieve the map
  MeshScoreMap fSMap = fScoringMesh->GetScoreMap();
  

  MeshScoreMap::const_iterator msMapItr = fSMap.find(psName);
  if(msMapItr == fSMap.end()) {
    G4cerr << "ERROR : DumpToFile : Unknown quantity, \""
       << psName << "\"." << G4endl;
    return;
  }


  std::map<G4int, G4double*> * 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 << ", value ";
  if(unit.size() > 0) ofile << "[" << unit << "]";
  ofile << 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 << ",";

    std::map<G4int, G4double*>::iterator value = score->find(idx);
    if(value == score->end()) {
      ofile << 0.;
    } else {
      ofile << *(value->second)/unitValue;
    }

    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();
  
}

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

protected

Definition at line 243 of file G4VScoreWriter.cc.

References fNMeshSegments, and z.

Referenced by DumpAllQuantitiesToFile(), DumpQuantityToFile(), RE03UserScoreWriter::DumpQuantityToFile(), and BrachyUserScoreWriter::DumpQuantityToFile().

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

void G4VScoreWriter::SetScoringMesh

(

G4VScoringMesh *

sm

)

Definition at line 48 of file G4VScoreWriter.cc.

References fNMeshSegments, fScoringMesh, G4VScoringMesh::GetNumberOfSegments(), and G4InuclParticleNames::sm.

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

                                                       {
    fScoringMesh = sm;
    fScoringMesh->GetNumberOfSegments(fNMeshSegments);
}

void G4VScoreWriter::SetVerboseLevel ( G4int  vl )

inline

Definition at line 59 of file G4VScoreWriter.hh.

References verboseLevel.

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

                                        {
    verboseLevel = vl;
  }

Field Documentation

G4int G4VScoreWriter::fNMeshSegments[3]

protected

Definition at line 68 of file G4VScoreWriter.hh.

Referenced by DumpAllQuantitiesToFile(), DumpQuantityToFile(), BrachyUserScoreWriter::DumpQuantityToFile(), RE03UserScoreWriter::DumpQuantityToFile(), G4VScoreWriter(), GetIndex(), and SetScoringMesh().

G4VScoringMesh* G4VScoreWriter::fScoringMesh

protected

Definition at line 69 of file G4VScoreWriter.hh.

Referenced by DumpAllQuantitiesToFile(), DumpQuantityToFile(), RE03UserScoreWriter::DumpQuantityToFile(), BrachyUserScoreWriter::DumpQuantityToFile(), and SetScoringMesh().

G4int G4VScoreWriter::verboseLevel

protected

Definition at line 70 of file G4VScoreWriter.hh.

Referenced by BrachyUserScoreWriter::DumpQuantityToFile(), RE03UserScoreWriter::DumpQuantityToFile(), and SetVerboseLevel().

---

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

• G4VScoreWriter.hh
• G4VScoreWriter.cc