#include <G4ScoringBox.hh>

Inheritance diagram for G4ScoringBox:

Public Types
using	EventScore = G4THitsMap< G4double >

using	MeshScoreMap = std::map< G4String, RunScore * >

enum class	MeshShape { box , cylinder , sphere , realWorldLogVol , probe , undefined = -1 }

using	RunScore = G4THitsMap< G4StatDouble >

Public Member Functions
void	Accumulate (G4THitsMap< G4double > *map)

void	Accumulate (G4THitsMap< G4StatDouble > *map)

void	Activate (G4bool vl=true)

virtual void	Construct (G4VPhysicalVolume *fWorldPhys)

void	Draw (RunScore map, G4VScoreColorMap colorMap, G4int axflg=111)

void	DrawColumn (RunScore map, G4VScoreColorMap colorMap, G4int idxProj, G4int idxColumn)

void	DrawMesh (const G4String &psName, G4int idxPlane, G4int iColumn, G4VScoreColorMap *colorMap)

void	DrawMesh (const G4String &psName, G4VScoreColorMap *colorMap, G4int axflg=111)

void	Dump ()

G4bool	FindPrimitiveScorer (const G4String &psname)

	G4ScoringBox (G4String wName)

void	GeometryHasBeenDestroyed ()

G4double	GetAngleSpan () const

G4int	GetCopyNumberLevel () const

G4String	GetCurrentPSUnit ()

void	GetDivisionAxisNames (G4String divisionAxisNames[3])

G4LogicalVolume *	GetMeshElementLogical () const

void	GetNumberOfSegments (G4int nSegment[3])

G4ParallelWorldProcess *	GetParallelWorldProcess () const

G4VPrimitiveScorer *	GetPrimitiveScorer (const G4String &name)

G4String	GetPSUnit (const G4String &psname)

G4double	GetPSUnitValue (const G4String &psname)

G4RotationMatrix	GetRotationMatrix () const

MeshScoreMap	GetScoreMap () const

MeshShape	GetShape () const

G4ThreeVector	GetSize () const

G4double	GetStartAngle () const

G4ThreeVector	GetTranslation () const

const G4String &	GetWorldName () const

G4bool	IsActive () const

G4bool	IsCurrentPrimitiveScorerNull ()

G4bool	LayeredMassFlg ()

void	List () const

void	Merge (const G4VScoringMesh *scMesh)

G4bool	ReadyForQuantity () const

void	ResetScore ()

void	RotateX (G4double delta)

void	RotateY (G4double delta)

void	RotateZ (G4double delta)

void	SetAngles (G4double, G4double)

void	SetCenterPosition (G4double centerPosition[3])

void	SetCopyNumberLevel (G4int val)

void	SetCurrentPrimitiveScorer (const G4String &name)

void	SetCurrentPSUnit (const G4String &unit)

void	SetDrawPSName (const G4String &psname)

void	SetFilter (G4VSDFilter *filter)

void	SetMeshElementLogical (G4LogicalVolume *val)

void	SetNullToCurrentPrimitiveScorer ()

void	SetNumberOfSegments (G4int nSegment[3])

void	SetParallelWorldProcess (G4ParallelWorldProcess *proc)

void	SetPrimitiveScorer (G4VPrimitiveScorer *ps)

void	SetSegmentDirection (G4int dir)

void	SetSize (G4double size[3])

void	SetVerboseLevel (G4int vl)

virtual void	WorkerConstruct (G4VPhysicalVolume *fWorldPhys)

	~G4ScoringBox ()

Protected Member Functions
virtual void	SetupGeometry (G4VPhysicalVolume *fWorldPhys)

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

G4ThreeVector	GetReplicaPosition (G4int x, G4int y, G4int z)

void	GetXYZ (G4int index, G4int q[3]) const

Private Attributes
G4int	fSegmentDirection

Detailed Description

Definition at line 42 of file G4ScoringBox.hh.

Member Typedef Documentation

◆ EventScore

using G4VScoringMesh::EventScore = G4THitsMap<G4double>

inherited

Definition at line 66 of file G4VScoringMesh.hh.

◆ MeshScoreMap

using G4VScoringMesh::MeshScoreMap = std::map<G4String, RunScore*>

inherited

Definition at line 68 of file G4VScoringMesh.hh.

◆ RunScore

using G4VScoringMesh::RunScore = G4THitsMap<G4StatDouble>

inherited

Definition at line 67 of file G4VScoringMesh.hh.

Member Enumeration Documentation

◆ MeshShape

enum class G4VScoringMesh::MeshShape

stronginherited

Enumerator
box
cylinder
sphere
realWorldLogVol
probe
undefined

Definition at line 57 of file G4VScoringMesh.hh.

  {
    box,
    cylinder,
    sphere,
    realWorldLogVol,
    probe,
    undefined = -1
  };

Constructor & Destructor Documentation

◆ G4ScoringBox()

G4ScoringBox::G4ScoringBox ( G4String wName )

Definition at line 54 of file G4ScoringBox.cc.

  : G4VScoringMesh(wName)
  , fSegmentDirection(-1)
{
  fShape                = MeshShape::box;
  fDivisionAxisNames[0] = "X";
  fDivisionAxisNames[1] = "Y";
  fDivisionAxisNames[2] = "Z";
}

References G4VScoringMesh::box, G4VScoringMesh::fDivisionAxisNames, and G4VScoringMesh::fShape.

◆ ~G4ScoringBox()

G4ScoringBox::~G4ScoringBox ( )

Definition at line 64 of file G4ScoringBox.cc.

64{}

Member Function Documentation

◆ Accumulate() [1/2]

void G4VScoringMesh::Accumulate ( G4THitsMap< G4double > * map )

inherited

Definition at line 386 of file G4VScoringMesh.cc.

{
  G4String psName                      = map->GetName();
  MeshScoreMap::const_iterator fMapItr = fMap.find(psName);
  *(fMapItr->second) += *map;
 
  if(verboseLevel > 9)
  {
    G4cout << G4endl;
    G4cout << "G4VScoringMesh::Accumulate()" << G4endl;
    G4cout << "  PS name : " << psName << G4endl;
    if(fMapItr == fMap.end())
    {
      G4cout << "  " << psName << " was not found." << G4endl;
    }
    else
    {
      G4cout << "  map size : " << map->GetSize() << G4endl;
      map->PrintAllHits();
    }
    G4cout << G4endl;
  }
}

References G4VScoringMesh::fMap, G4cout, G4endl, anonymous_namespace{G4QuasiElRatios.cc}::map, and G4VScoringMesh::verboseLevel.

◆ Accumulate() [2/2]

void G4VScoringMesh::Accumulate ( G4THitsMap< G4StatDouble > * map )

inherited

Definition at line 410 of file G4VScoringMesh.cc.

{
  G4String psName                      = map->GetName();
  MeshScoreMap::const_iterator fMapItr = fMap.find(psName);
  *(fMapItr->second) += *map;
 
  if(verboseLevel > 9)
  {
    G4cout << G4endl;
    G4cout << "G4VScoringMesh::Accumulate()" << G4endl;
    G4cout << "  PS name : " << psName << G4endl;
    if(fMapItr == fMap.end())
    {
      G4cout << "  " << psName << " was not found." << G4endl;
    }
    else
    {
      G4cout << "  map size : " << map->GetSize() << G4endl;
      map->PrintAllHits();
    }
    G4cout << G4endl;
  }
}

References G4VScoringMesh::fMap, G4cout, G4endl, anonymous_namespace{G4QuasiElRatios.cc}::map, and G4VScoringMesh::verboseLevel.

◆ Activate()

void G4VScoringMesh::Activate ( G4bool vl = true )

inlineinherited

Definition at line 95 of file G4VScoringMesh.hh.

95{ fActive = vl; }

G4VScoringMesh::fActive

G4bool fActive

Definition: G4VScoringMesh.hh:202

References G4VScoringMesh::fActive.

◆ Construct()

void G4VScoringMesh::Construct ( G4VPhysicalVolume * fWorldPhys )

virtualinherited

Definition at line 434 of file G4VScoringMesh.cc.

{
  if(fConstructed)
  {
    if(fGeometryHasBeenDestroyed)
    {
      SetupGeometry(fWorldPhys);
      fGeometryHasBeenDestroyed = false;
    }
    if(verboseLevel > 0)
      G4cout << fWorldName << " --- All quantities are reset." << G4endl;
    ResetScore();
  }
  else
  {
    fConstructed = true;
    SetupGeometry(fWorldPhys);
  }
}

References G4VScoringMesh::fConstructed, G4VScoringMesh::fGeometryHasBeenDestroyed, G4VScoringMesh::fWorldName, G4cout, G4endl, G4VScoringMesh::ResetScore(), G4VScoringMesh::SetupGeometry(), and G4VScoringMesh::verboseLevel.

Referenced by G4RunManager::ConstructScoringWorlds().

◆ Draw()

void G4ScoringBox::Draw	(	RunScore *	map,
		G4VScoreColorMap *	colorMap,
		G4int	axflg = `111`
	)

virtual

Implements G4VScoringMesh.

Definition at line 247 of file G4ScoringBox.cc.

{
  G4VVisManager* pVisManager = G4VVisManager::GetConcreteInstance();
  if(pVisManager)
  {
    // cell vectors
    std::vector<std::vector<std::vector<double>>> cell;  // cell[X][Y][Z]
    std::vector<double> ez;
    for(int z = 0; z < fNSegment[2]; z++)
      ez.push_back(0.);
    std::vector<std::vector<double>> eyz;
    for(int y = 0; y < fNSegment[1]; y++)
      eyz.push_back(ez);
    for(int x = 0; x < fNSegment[0]; x++)
      cell.push_back(eyz);
 
    std::vector<std::vector<double>> xycell;  // xycell[X][Y]
    std::vector<double> ey;
    for(int y = 0; y < fNSegment[1]; y++)
      ey.push_back(0.);
    for(int x = 0; x < fNSegment[0]; x++)
      xycell.push_back(ey);
 
    std::vector<std::vector<double>> yzcell;  // yzcell[Y][Z]
    for(int y = 0; y < fNSegment[1]; y++)
      yzcell.push_back(ez);
 
    std::vector<std::vector<double>> xzcell;  // xzcell[X][Z]
    for(int x = 0; x < fNSegment[0]; x++)
      xzcell.push_back(ez);
 
    // projections
    G4int q[3];
    std::map<G4int, G4StatDouble*>::iterator itr = map->GetMap()->begin();
    for(; itr != map->GetMap()->end(); itr++)
    {
      GetXYZ(itr->first, q);
 
      xycell[q[0]][q[1]] += (itr->second->sum_wx()) / fDrawUnitValue;
      yzcell[q[1]][q[2]] += (itr->second->sum_wx()) / fDrawUnitValue;
      xzcell[q[0]][q[2]] += (itr->second->sum_wx()) / fDrawUnitValue;
    }
 
    // search max. & min. values in each slice
    G4double xymin = DBL_MAX, yzmin = DBL_MAX, xzmin = DBL_MAX;
    G4double xymax = 0., yzmax = 0., xzmax = 0.;
    for(int x = 0; x < fNSegment[0]; x++)
    {
      for(int y = 0; y < fNSegment[1]; y++)
      {
        if(xymin > xycell[x][y])
          xymin = xycell[x][y];
        if(xymax < xycell[x][y])
          xymax = xycell[x][y];
      }
      for(int z = 0; z < fNSegment[2]; z++)
      {
        if(xzmin > xzcell[x][z])
          xzmin = xzcell[x][z];
        if(xzmax < xzcell[x][z])
          xzmax = xzcell[x][z];
      }
    }
    for(int y = 0; y < fNSegment[1]; y++)
    {
      for(int z = 0; z < fNSegment[2]; z++)
      {
        if(yzmin > yzcell[y][z])
          yzmin = yzcell[y][z];
        if(yzmax < yzcell[y][z])
          yzmax = yzcell[y][z];
      }
    }
 
    G4VisAttributes att;
    att.SetForceSolid(true);
    att.SetForceAuxEdgeVisible(true);
    G4double thick = 0.01;
 
    G4Scale3D scale;
    if(axflg / 100 == 1)
    {
      pVisManager->BeginDraw();
 
      // xy plane
      if(colorMap->IfFloatMinMax())
      {
        colorMap->SetMinMax(xymin, xymax);
      }
      G4ThreeVector zhalf(0., 0., fSize[2] / fNSegment[2] - thick);
      for(int x = 0; x < fNSegment[0]; x++)
      {
        for(int y = 0; y < fNSegment[1]; y++)
        {
          G4ThreeVector pos(GetReplicaPosition(x, y, 0) - zhalf);
          G4ThreeVector pos2(GetReplicaPosition(x, y, fNSegment[2] - 1) +
                             zhalf);
          G4Transform3D trans, trans2;
          if(fRotationMatrix)
          {
            trans = G4Rotate3D(*fRotationMatrix).inverse() * G4Translate3D(pos);
            trans = G4Translate3D(fCenterPosition) * trans;
            trans2 =
              G4Rotate3D(*fRotationMatrix).inverse() * G4Translate3D(pos2);
            trans2 = G4Translate3D(fCenterPosition) * trans2;
          }
          else
          {
            trans  = G4Translate3D(pos) * G4Translate3D(fCenterPosition);
            trans2 = G4Translate3D(pos2) * G4Translate3D(fCenterPosition);
          }
          G4double c[4];
          colorMap->GetMapColor(xycell[x][y], c);
          att.SetColour(c[0], c[1], c[2]);  //, c[3]);
 
          G4Box xyplate("xy", fSize[0] / fNSegment[0], fSize[1] / fNSegment[1],
                        thick);
          G4Polyhedron* poly = xyplate.GetPolyhedron();
          poly->Transform(trans);
          poly->SetVisAttributes(&att);
          pVisManager->Draw(*poly);
 
          G4Box xyplate2      = xyplate;
          G4Polyhedron* poly2 = xyplate2.GetPolyhedron();
          poly2->Transform(trans2);
          poly2->SetVisAttributes(&att);
          pVisManager->Draw(*poly2);
 
          /*
          G4double nodes[][3] =
            {{-fSize[0]/fNSegment[0], -fSize[1]/fNSegment[1], 0.},
             { fSize[0]/fNSegment[0], -fSize[1]/fNSegment[1], 0.},
             { fSize[0]/fNSegment[0],  fSize[1]/fNSegment[1], 0.},
             {-fSize[0]/fNSegment[0],  fSize[1]/fNSegment[1], 0.}};
          G4int facets[][4] = {{4, 3, 2, 1}};
          G4int facets2[][4] = {{1, 2, 3, 4}};
 
          G4Polyhedron poly, poly2;
          poly.createPolyhedron(4, 1, nodes, facets);
          poly.Transform(trans);
          poly.SetVisAttributes(att);
          pVisManager->Draw(poly);
 
          poly2.createPolyhedron(4, 1, nodes, facets2);
          poly2.Transform(trans2);
          poly2.SetVisAttributes(att);
          pVisManager->Draw(poly2);
          */
        }
      }
      pVisManager->EndDraw();
    }
    axflg = axflg % 100;
    if(axflg / 10 == 1)
    {
      pVisManager->BeginDraw();
 
      // yz plane
      if(colorMap->IfFloatMinMax())
      {
        colorMap->SetMinMax(yzmin, yzmax);
      }
      G4ThreeVector xhalf(fSize[0] / fNSegment[0] - thick, 0., 0.);
      for(int y = 0; y < fNSegment[1]; y++)
      {
        for(int z = 0; z < fNSegment[2]; z++)
        {
          G4ThreeVector pos(GetReplicaPosition(0, y, z) - xhalf);
          G4ThreeVector pos2(GetReplicaPosition(fNSegment[0] - 1, y, z) +
                             xhalf);
          G4Transform3D trans, trans2;
          if(fRotationMatrix)
          {
            trans = G4Rotate3D(*fRotationMatrix).inverse() * G4Translate3D(pos);
            trans = G4Translate3D(fCenterPosition) * trans;
            trans2 =
              G4Rotate3D(*fRotationMatrix).inverse() * G4Translate3D(pos2);
            trans2 = G4Translate3D(fCenterPosition) * trans2;
          }
          else
          {
            trans  = G4Translate3D(pos) * G4Translate3D(fCenterPosition);
            trans2 = G4Translate3D(pos2) * G4Translate3D(fCenterPosition);
          }
          G4double c[4];
          colorMap->GetMapColor(yzcell[y][z], c);
          att.SetColour(c[0], c[1], c[2]);  //, c[3]);
 
          G4Box yzplate("yz", thick,  // fSize[0]/fNSegment[0]*0.001,
                        fSize[1] / fNSegment[1], fSize[2] / fNSegment[2]);
          G4Polyhedron* poly = yzplate.GetPolyhedron();
          poly->Transform(trans);
          poly->SetVisAttributes(&att);
          pVisManager->Draw(*poly);
 
          G4Box yzplate2      = yzplate;
          G4Polyhedron* poly2 = yzplate2.GetPolyhedron();
          poly2->Transform(trans2);
          poly2->SetVisAttributes(&att);
          pVisManager->Draw(*poly2);
 
          /*
          G4double nodes[][3] =
          {{0., -fSize[1]/fNSegment[1], -fSize[2]/fNSegment[2]},
           {0.,  fSize[1]/fNSegment[1], -fSize[2]/fNSegment[2]},
           {0.,  fSize[1]/fNSegment[1],  fSize[2]/fNSegment[2]},
           {0., -fSize[1]/fNSegment[1],  fSize[2]/fNSegment[2]}};
          G4int facets[][4] = {{4, 3, 2, 1}};
          G4int facets2[][4] = {{1, 2, 3, 4}};
 
          G4Polyhedron poly, poly2;
          poly.createPolyhedron(4, 1, nodes, facets);
          poly.Transform(trans);
          poly.SetVisAttributes(att);
          pVisManager->Draw(poly);
 
          poly2.createPolyhedron(4, 1, nodes, facets2);
          poly2.Transform(trans2);
          poly2.SetVisAttributes(att);
          pVisManager->Draw(poly2);
          */
        }
      }
      pVisManager->EndDraw();
    }
    axflg = axflg % 10;
    if(axflg == 1)
    {
      pVisManager->BeginDraw();
 
      // xz plane
      if(colorMap->IfFloatMinMax())
      {
        colorMap->SetMinMax(xzmin, xzmax);
      }
      G4ThreeVector yhalf(0., fSize[1] / fNSegment[1] - thick, 0.);
      for(int x = 0; x < fNSegment[0]; x++)
      {
        for(int z = 0; z < fNSegment[2]; z++)
        {
          G4ThreeVector pos(GetReplicaPosition(x, 0, z) - yhalf);
          G4ThreeVector pos2(GetReplicaPosition(x, fNSegment[1] - 1, z) +
                             yhalf);
          G4Transform3D trans, trans2;
          if(fRotationMatrix)
          {
            trans = G4Rotate3D(*fRotationMatrix).inverse() * G4Translate3D(pos);
            trans = G4Translate3D(fCenterPosition) * trans;
            trans2 =
              G4Rotate3D(*fRotationMatrix).inverse() * G4Translate3D(pos2);
            trans2 = G4Translate3D(fCenterPosition) * trans2;
          }
          else
          {
            trans  = G4Translate3D(pos) * G4Translate3D(fCenterPosition);
            trans2 = G4Translate3D(pos2) * G4Translate3D(fCenterPosition);
          }
          G4double c[4];
          colorMap->GetMapColor(xzcell[x][z], c);
          att.SetColour(c[0], c[1], c[2]);  //, c[3]);
 
          G4Box xzplate("xz", fSize[0] / fNSegment[0],
                        thick,  // fSize[1]/fNSegment[1]*0.001,
                        fSize[2] / fNSegment[2]);
          G4Polyhedron* poly = xzplate.GetPolyhedron();
          poly->Transform(trans);
          poly->SetVisAttributes(&att);
          pVisManager->Draw(*poly);
 
          G4Box xzplate2      = xzplate;
          G4Polyhedron* poly2 = xzplate2.GetPolyhedron();
          poly2->Transform(trans2);
          poly2->SetVisAttributes(&att);
          pVisManager->Draw(*poly2);
 
          /*
          G4double nodes[][3] =
          {{-fSize[1]/fNSegment[1], 0., -fSize[2]/fNSegment[2]},
           { fSize[1]/fNSegment[1], 0., -fSize[2]/fNSegment[2]},
           { fSize[1]/fNSegment[1], 0.,  fSize[2]/fNSegment[2]},
           {-fSize[1]/fNSegment[1], 0.,  fSize[2]/fNSegment[2]}};
          G4int facets[][4] = {{1, 2, 3, 4}};
          G4int facets2[][4] = {{4, 3, 2, 1}};
 
          G4Polyhedron poly, poly2;
          poly.createPolyhedron(4, 1, nodes, facets);
          poly.Transform(trans);
          poly.SetVisAttributes(att);
          pVisManager->Draw(poly);
 
          poly2.createPolyhedron(4, 1, nodes, facets2);
          poly2.Transform(trans2);
          poly2.SetVisAttributes(att);
          pVisManager->Draw(poly2);
          */
        }
      }
      pVisManager->EndDraw();
    }
  }
  colorMap->SetPSUnit(fDrawUnit);
  colorMap->SetPSName(fDrawPSName);
  colorMap->DrawColorChart();
}

References G4VVisManager::BeginDraw(), DBL_MAX, G4VVisManager::Draw(), G4VScoreColorMap::DrawColorChart(), G4VVisManager::EndDraw(), G4VScoringMesh::fCenterPosition, G4VScoringMesh::fDrawPSName, G4VScoringMesh::fDrawUnit, G4VScoringMesh::fDrawUnitValue, G4VScoringMesh::fNSegment, G4VScoringMesh::fRotationMatrix, G4VScoringMesh::fSize, G4VVisManager::GetConcreteInstance(), G4VScoreColorMap::GetMapColor(), G4CSGSolid::GetPolyhedron(), GetReplicaPosition(), GetXYZ(), G4VScoreColorMap::IfFloatMinMax(), HepGeom::Transform3D::inverse(), anonymous_namespace{G4QuasiElRatios.cc}::map, pos, G4VisAttributes::SetColour(), G4VisAttributes::SetForceAuxEdgeVisible(), G4VisAttributes::SetForceSolid(), G4VScoreColorMap::SetMinMax(), G4VScoreColorMap::SetPSName(), G4VScoreColorMap::SetPSUnit(), G4Visible::SetVisAttributes(), and HepPolyhedron::Transform().

◆ DrawColumn()

void G4ScoringBox::DrawColumn	(	RunScore *	map,
		G4VScoreColorMap *	colorMap,
		G4int	idxProj,
		G4int	idxColumn
	)

virtual

Implements G4VScoringMesh.

Definition at line 575 of file G4ScoringBox.cc.

{
  G4int iColumn[3] = { 2, 0, 1 };
  if(idxColumn < 0 || idxColumn >= fNSegment[iColumn[idxProj]])
  {
    G4cerr << "ERROR : Column number " << idxColumn
           << " is out of scoring mesh [0," << fNSegment[iColumn[idxProj]] - 1
           << "]. Method ignored." << G4endl;
    return;
  }
  G4VVisManager* pVisManager = G4VVisManager::GetConcreteInstance();
  if(pVisManager)
  {
    pVisManager->BeginDraw();
 
    // cell vectors
    std::vector<std::vector<std::vector<double>>> cell;  // cell[X][Y][Z]
    std::vector<double> ez;
    for(int z = 0; z < fNSegment[2]; z++)
      ez.push_back(0.);
    std::vector<std::vector<double>> eyz;
    for(int y = 0; y < fNSegment[1]; y++)
      eyz.push_back(ez);
    for(int x = 0; x < fNSegment[0]; x++)
      cell.push_back(eyz);
 
    std::vector<std::vector<double>> xycell;  // xycell[X][Y]
    std::vector<double> ey;
    for(int y = 0; y < fNSegment[1]; y++)
      ey.push_back(0.);
    for(int x = 0; x < fNSegment[0]; x++)
      xycell.push_back(ey);
 
    std::vector<std::vector<double>> yzcell;  // yzcell[Y][Z]
    for(int y = 0; y < fNSegment[1]; y++)
      yzcell.push_back(ez);
 
    std::vector<std::vector<double>> xzcell;  // xzcell[X][Z]
    for(int x = 0; x < fNSegment[0]; x++)
      xzcell.push_back(ez);
 
    // projections
    G4int q[3];
    std::map<G4int, G4StatDouble*>::iterator itr = map->GetMap()->begin();
    for(; itr != map->GetMap()->end(); itr++)
    {
      GetXYZ(itr->first, q);
 
      if(idxProj == 0 && q[2] == idxColumn)
      {  // xy plane
        xycell[q[0]][q[1]] += (itr->second->sum_wx()) / fDrawUnitValue;
      }
      if(idxProj == 1 && q[0] == idxColumn)
      {  // yz plane
        yzcell[q[1]][q[2]] += (itr->second->sum_wx()) / fDrawUnitValue;
      }
      if(idxProj == 2 && q[1] == idxColumn)
      {  // zx plane
        xzcell[q[0]][q[2]] += (itr->second->sum_wx()) / fDrawUnitValue;
      }
    }
 
    // search max. & min. values in each slice
    G4double xymin = DBL_MAX, yzmin = DBL_MAX, xzmin = DBL_MAX;
    G4double xymax = 0., yzmax = 0., xzmax = 0.;
    for(int x = 0; x < fNSegment[0]; x++)
    {
      for(int y = 0; y < fNSegment[1]; y++)
      {
        if(xymin > xycell[x][y])
          xymin = xycell[x][y];
        if(xymax < xycell[x][y])
          xymax = xycell[x][y];
      }
      for(int z = 0; z < fNSegment[2]; z++)
      {
        if(xzmin > xzcell[x][z])
          xzmin = xzcell[x][z];
        if(xzmax < xzcell[x][z])
          xzmax = xzcell[x][z];
      }
    }
    for(int y = 0; y < fNSegment[1]; y++)
    {
      for(int z = 0; z < fNSegment[2]; z++)
      {
        if(yzmin > yzcell[y][z])
          yzmin = yzcell[y][z];
        if(yzmax < yzcell[y][z])
          yzmax = yzcell[y][z];
      }
    }
 
    G4VisAttributes att;
    att.SetForceSolid(true);
    att.SetForceAuxEdgeVisible(true);
 
    G4Scale3D scale;
    // xy plane
    if(idxProj == 0)
    {
      if(colorMap->IfFloatMinMax())
      {
        colorMap->SetMinMax(xymin, xymax);
      }
      for(int x = 0; x < fNSegment[0]; x++)
      {
        for(int y = 0; y < fNSegment[1]; y++)
        {
          G4Box xyplate("xy", fSize[0] / fNSegment[0], fSize[1] / fNSegment[1],
                        fSize[2] / fNSegment[2]);
 
          G4ThreeVector pos(GetReplicaPosition(x, y, idxColumn));
          G4Transform3D trans;
          if(fRotationMatrix)
          {
            trans = G4Rotate3D(*fRotationMatrix).inverse() * G4Translate3D(pos);
            trans = G4Translate3D(fCenterPosition) * trans;
          }
          else
          {
            trans = G4Translate3D(pos) * G4Translate3D(fCenterPosition);
          }
          G4double c[4];
          colorMap->GetMapColor(xycell[x][y], c);
          att.SetColour(c[0], c[1], c[2]);
 
          G4Polyhedron* poly = xyplate.GetPolyhedron();
          poly->Transform(trans);
          poly->SetVisAttributes(att);
          pVisManager->Draw(*poly);
        }
      }
    }
    else
      // yz plane
      if(idxProj == 1)
    {
      if(colorMap->IfFloatMinMax())
      {
        colorMap->SetMinMax(yzmin, yzmax);
      }
      for(int y = 0; y < fNSegment[1]; y++)
      {
        for(int z = 0; z < fNSegment[2]; z++)
        {
          G4Box yzplate("yz", fSize[0] / fNSegment[0], fSize[1] / fNSegment[1],
                        fSize[2] / fNSegment[2]);
 
          G4ThreeVector pos(GetReplicaPosition(idxColumn, y, z));
          G4Transform3D trans;
          if(fRotationMatrix)
          {
            trans = G4Rotate3D(*fRotationMatrix).inverse() * G4Translate3D(pos);
            trans = G4Translate3D(fCenterPosition) * trans;
          }
          else
          {
            trans = G4Translate3D(pos) * G4Translate3D(fCenterPosition);
          }
          G4double c[4];
          colorMap->GetMapColor(yzcell[y][z], c);
          att.SetColour(c[0], c[1], c[2]);  //, c[3]);
 
          G4Polyhedron* poly = yzplate.GetPolyhedron();
          poly->Transform(trans);
          poly->SetVisAttributes(att);
          pVisManager->Draw(*poly);
        }
      }
    }
    else
      // xz plane
      if(idxProj == 2)
    {
      if(colorMap->IfFloatMinMax())
      {
        colorMap->SetMinMax(xzmin, xzmax);
      }
      for(int x = 0; x < fNSegment[0]; x++)
      {
        for(int z = 0; z < fNSegment[2]; z++)
        {
          G4Box xzplate("xz", fSize[0] / fNSegment[0], fSize[1] / fNSegment[1],
                        fSize[2] / fNSegment[2]);
 
          G4ThreeVector pos(GetReplicaPosition(x, idxColumn, z));
          G4Transform3D trans;
          if(fRotationMatrix)
          {
            trans = G4Rotate3D(*fRotationMatrix).inverse() * G4Translate3D(pos);
            trans = G4Translate3D(fCenterPosition) * trans;
          }
          else
          {
            trans = G4Translate3D(pos) * G4Translate3D(fCenterPosition);
          }
          G4double c[4];
          colorMap->GetMapColor(xzcell[x][z], c);
          att.SetColour(c[0], c[1], c[2]);  //, c[3]);
 
          G4Polyhedron* poly = xzplate.GetPolyhedron();
          poly->Transform(trans);
          poly->SetVisAttributes(att);
          pVisManager->Draw(*poly);
        }
      }
    }
    pVisManager->EndDraw();
  }
 
  colorMap->SetPSUnit(fDrawUnit);
  colorMap->SetPSName(fDrawPSName);
  colorMap->DrawColorChart();
}

References G4VVisManager::BeginDraw(), DBL_MAX, G4VVisManager::Draw(), G4VScoreColorMap::DrawColorChart(), G4VVisManager::EndDraw(), G4VScoringMesh::fCenterPosition, G4VScoringMesh::fDrawPSName, G4VScoringMesh::fDrawUnit, G4VScoringMesh::fDrawUnitValue, G4VScoringMesh::fNSegment, G4VScoringMesh::fRotationMatrix, G4VScoringMesh::fSize, G4cerr, G4endl, G4VVisManager::GetConcreteInstance(), G4VScoreColorMap::GetMapColor(), G4CSGSolid::GetPolyhedron(), GetReplicaPosition(), GetXYZ(), G4VScoreColorMap::IfFloatMinMax(), HepGeom::Transform3D::inverse(), anonymous_namespace{G4QuasiElRatios.cc}::map, pos, G4VisAttributes::SetColour(), G4VisAttributes::SetForceAuxEdgeVisible(), G4VisAttributes::SetForceSolid(), G4VScoreColorMap::SetMinMax(), G4VScoreColorMap::SetPSName(), G4VScoreColorMap::SetPSUnit(), G4Visible::SetVisAttributes(), and HepPolyhedron::Transform().

◆ DrawMesh() [1/2]

void G4VScoringMesh::DrawMesh	(	const G4String &	psName,
		G4int	idxPlane,
		G4int	iColumn,
		G4VScoreColorMap *	colorMap
	)

inherited

Definition at line 368 of file G4VScoringMesh.cc.

{
  fDrawPSName                          = psName;
  MeshScoreMap::const_iterator fMapItr = fMap.find(psName);
  if(fMapItr != fMap.end())
  {
    fDrawUnit      = GetPSUnit(psName);
    fDrawUnitValue = GetPSUnitValue(psName);
    DrawColumn(fMapItr->second, colorMap, idxPlane, iColumn);
  }
  else
  {
    G4cerr << "Scorer <" << psName << "> is not defined. Method ignored."
           << G4endl;
  }
}

References G4VScoringMesh::DrawColumn(), G4VScoringMesh::fDrawPSName, G4VScoringMesh::fDrawUnit, G4VScoringMesh::fDrawUnitValue, G4VScoringMesh::fMap, G4cerr, G4endl, G4VScoringMesh::GetPSUnit(), and G4VScoringMesh::GetPSUnitValue().

◆ DrawMesh() [2/2]

void G4VScoringMesh::DrawMesh	(	const G4String &	psName,
		G4VScoreColorMap *	colorMap,
		G4int	axflg = `111`
	)

inherited

Definition at line 350 of file G4VScoringMesh.cc.

{
  fDrawPSName                          = psName;
  MeshScoreMap::const_iterator fMapItr = fMap.find(psName);
  if(fMapItr != fMap.end())
  {
    fDrawUnit      = GetPSUnit(psName);
    fDrawUnitValue = GetPSUnitValue(psName);
    Draw(fMapItr->second, colorMap, axflg);
  }
  else
  {
    G4cerr << "Scorer <" << psName << "> is not defined. Method ignored."
           << G4endl;
  }
}

References G4VScoringMesh::Draw(), G4VScoringMesh::fDrawPSName, G4VScoringMesh::fDrawUnit, G4VScoringMesh::fDrawUnitValue, G4VScoringMesh::fMap, G4cerr, G4endl, G4VScoringMesh::GetPSUnit(), and G4VScoringMesh::GetPSUnitValue().

Referenced by G4VSceneHandler::AddCompound(), and G4ScoringManager::DrawMesh().

◆ Dump()

void G4VScoringMesh::Dump ( )

inherited

Definition at line 338 of file G4VScoringMesh.cc.

{
  G4cout << "scoring mesh name: " << fWorldName << G4endl;
  G4cout << "# of G4THitsMap : " << fMap.size() << G4endl;
  for(auto mp : fMap)
  {
    G4cout << "[" << mp.first << "]" << G4endl;
    mp.second->PrintAllHits();
  }
  G4cout << G4endl;
}

References G4VScoringMesh::fMap, G4VScoringMesh::fWorldName, G4cout, and G4endl.

◆ FindPrimitiveScorer()

G4bool G4VScoringMesh::FindPrimitiveScorer ( const G4String & psname )

inherited

Definition at line 223 of file G4VScoringMesh.cc.

{
  MeshScoreMap::iterator itr = fMap.find(psname);
  if(itr == fMap.end())
    return false;
  return true;
}

References G4VScoringMesh::fMap.

Referenced by G4ScoreQuantityMessenger::CheckMeshPS().

◆ GeometryHasBeenDestroyed()

void G4VScoringMesh::GeometryHasBeenDestroyed ( )

inlineinherited

Definition at line 250 of file G4VScoringMesh.hh.

  {
    fGeometryHasBeenDestroyed = true;
    fMeshElementLogical       = nullptr;
  }

References G4VScoringMesh::fGeometryHasBeenDestroyed, and G4VScoringMesh::fMeshElementLogical.

Referenced by G4RunManager::ConstructScoringWorlds(), and G4WorkerRunManager::ConstructScoringWorlds().

◆ GetAngleSpan()

G4double G4VScoringMesh::GetAngleSpan ( ) const

inlineinherited

Definition at line 129 of file G4VScoringMesh.hh.

129{ return fAngle[1]; }

G4VScoringMesh::fAngle

G4double fAngle[2]

Definition: G4VScoringMesh.hh:206

References G4VScoringMesh::fAngle.

Referenced by G4ScoreQuantityMessenger::SetNewValue().

◆ GetCopyNumberLevel()

G4int G4VScoringMesh::GetCopyNumberLevel ( ) const

inlineinherited

Definition at line 263 of file G4VScoringMesh.hh.

263{ return copyNumberLevel; }

G4VScoringMesh::copyNumberLevel

G4int copyNumberLevel

Definition: G4VScoringMesh.hh:257

References G4VScoringMesh::copyNumberLevel.

Referenced by G4ScoreQuantityMessenger::SetNewValue().

◆ GetCurrentPSUnit()

G4String G4VScoringMesh::GetCurrentPSUnit ( )

inherited

Definition at line 244 of file G4VScoringMesh.cc.

{
  G4String unit = "";
  if(!fCurrentPS)
  {
    G4String msg = "ERROR : G4VScoringMesh::GetCurrentPSUnit() : ";
    msg += " Current primitive scorer is null.";
    G4cerr << msg << G4endl;
  }
  else
  {
    unit = fCurrentPS->GetUnit();
  }
  return unit;
}

References G4VScoringMesh::fCurrentPS, G4cerr, G4endl, and G4VPrimitiveScorer::GetUnit().

Referenced by G4ScoreQuantityMessenger::SetNewValue().

◆ GetDivisionAxisNames()

void G4VScoringMesh::GetDivisionAxisNames ( G4String divisionAxisNames[3] )

inherited

Definition at line 287 of file G4VScoringMesh.cc.

{
  for(int i = 0; i < 3; i++)
    divisionAxisNames[i] = fDivisionAxisNames[i];
}

References G4VScoringMesh::fDivisionAxisNames.

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

◆ GetIndex()

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

private

Definition at line 570 of file G4ScoringBox.cc.

{
  return x + y * fNSegment[0] + z * fNSegment[0] * fNSegment[1];
}

References G4VScoringMesh::fNSegment.

◆ GetMeshElementLogical()

G4LogicalVolume * G4VScoringMesh::GetMeshElementLogical ( ) const

inlineinherited

Definition at line 232 of file G4VScoringMesh.hh.

  {
    return fMeshElementLogical;
  }

References G4VScoringMesh::fMeshElementLogical.

Referenced by G4WorkerRunManager::ConstructScoringWorlds().

◆ GetNumberOfSegments()

void G4VScoringMesh::GetNumberOfSegments ( G4int nSegment[3] )

inherited

Definition at line 140 of file G4VScoringMesh.cc.

{
  for(int i = 0; i < 3; i++)
    nSegment[i] = fNSegment[i];
}

References G4VScoringMesh::fNSegment.

Referenced by G4GMocrenFileSceneHandler::AddSolid(), G4ScoreQuantityMessenger::SetNewValue(), and G4VScoreWriter::SetScoringMesh().

◆ GetParallelWorldProcess()

G4ParallelWorldProcess * G4VScoringMesh::GetParallelWorldProcess ( ) const

inlineinherited

Definition at line 246 of file G4VScoringMesh.hh.

  {
    return fParallelWorldProcess;
  }

References G4VScoringMesh::fParallelWorldProcess.

Referenced by G4RunManager::ConstructScoringWorlds(), and G4WorkerRunManager::ConstructScoringWorlds().

◆ GetPrimitiveScorer()

G4VPrimitiveScorer * G4VScoringMesh::GetPrimitiveScorer ( const G4String & name )

inherited

Definition at line 293 of file G4VScoringMesh.cc.

{
  if(!fMFD)
    return nullptr;
 
  G4int nps = fMFD->GetNumberOfPrimitives();
  for(G4int i = 0; i < nps; i++)
  {
    G4VPrimitiveScorer* prs = fMFD->GetPrimitive(i);
    if(name == prs->GetName())
      return prs;
  }
 
  return nullptr;
}

References G4VScoringMesh::fMFD, G4VPrimitiveScorer::GetName(), G4MultiFunctionalDetector::GetNumberOfPrimitives(), G4MultiFunctionalDetector::GetPrimitive(), G4InuclParticleNames::name(), and anonymous_namespace{G4QuasiElRatios.cc}::nps.

Referenced by G4VScoringMesh::GetPSUnit(), G4VScoringMesh::GetPSUnitValue(), and G4VScoringMesh::SetCurrentPrimitiveScorer().

◆ GetPSUnit()

G4String G4VScoringMesh::GetPSUnit ( const G4String & psname )

inherited

Definition at line 231 of file G4VScoringMesh.cc.

{
  MeshScoreMap::iterator itr = fMap.find(psname);
  if(itr == fMap.end())
  {
    return G4String("");
  }
  else
  {
    return GetPrimitiveScorer(psname)->GetUnit();
  }
}

References G4VScoringMesh::fMap, G4VScoringMesh::GetPrimitiveScorer(), and G4VPrimitiveScorer::GetUnit().

Referenced by G4VScoringMesh::DrawMesh(), G4VScoreWriter::DumpAllQuantitiesToFile(), and G4VScoreWriter::DumpQuantityToFile().

◆ GetPSUnitValue()

G4double G4VScoringMesh::GetPSUnitValue ( const G4String & psname )

inherited

Definition at line 274 of file G4VScoringMesh.cc.

{
  MeshScoreMap::iterator itr = fMap.find(psname);
  if(itr == fMap.end())
  {
    return 1.;
  }
  else
  {
    return GetPrimitiveScorer(psname)->GetUnitValue();
  }
}

References G4VScoringMesh::fMap, G4VScoringMesh::GetPrimitiveScorer(), and G4VPrimitiveScorer::GetUnitValue().

Referenced by G4VScoringMesh::DrawMesh(), G4VScoreWriter::DumpAllQuantitiesToFile(), and G4VScoreWriter::DumpQuantityToFile().

◆ GetReplicaPosition()

G4ThreeVector G4ScoringBox::GetReplicaPosition	(	G4int	x,
		G4int	y,
		G4int	z
	)

private

Definition at line 552 of file G4ScoringBox.cc.

{
  G4ThreeVector width(fSize[0] / fNSegment[0], fSize[1] / fNSegment[1],
                      fSize[2] / fNSegment[2]);
  G4ThreeVector pos(-fSize[0] + 2 * (x + 0.5) * width.x(),
                    -fSize[1] + 2 * (y + 0.5) * width.y(),
                    -fSize[2] + 2 * (z + 0.5) * width.z());
 
  return pos;
}

References G4VScoringMesh::fNSegment, G4VScoringMesh::fSize, pos, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by Draw(), and DrawColumn().

◆ GetRotationMatrix()

G4RotationMatrix G4VScoringMesh::GetRotationMatrix ( ) const

inlineinherited

Definition at line 141 of file G4VScoringMesh.hh.

  {
    if(fRotationMatrix)
      return *fRotationMatrix;
    else
      return G4RotationMatrix::IDENTITY;
  }

References G4VScoringMesh::fRotationMatrix, and CLHEP::HepRotation::IDENTITY.

Referenced by G4GMocrenFileSceneHandler::AddSolid().

◆ GetScoreMap()

MeshScoreMap G4VScoringMesh::GetScoreMap ( ) const

inlineinherited

Definition at line 190 of file G4VScoringMesh.hh.

190{ return fMap; }

References G4VScoringMesh::fMap.

Referenced by G4VSceneHandler::AddCompound(), G4PSHitsModel::DescribeYourselfTo(), G4VScoreWriter::DumpAllQuantitiesToFile(), G4VScoreWriter::DumpQuantityToFile(), and G4VScoringMesh::Merge().

◆ GetShape()

MeshShape G4VScoringMesh::GetShape ( ) const

inlineinherited

Definition at line 97 of file G4VScoringMesh.hh.

97{ return fShape; }

References G4VScoringMesh::fShape.

Referenced by G4RunManager::ConstructScoringWorlds(), G4WorkerRunManager::ConstructScoringWorlds(), G4ScoreQuantityMessenger::SetNewValue(), and G4ScoringMessenger::SetNewValue().

◆ GetSize()

G4ThreeVector G4VScoringMesh::GetSize ( ) const

inherited

Definition at line 105 of file G4VScoringMesh.cc.

{
  if(sizeIsSet)
    return G4ThreeVector(fSize[0], fSize[1], fSize[2]);
  else
    return G4ThreeVector(0., 0., 0.);
}

References G4VScoringMesh::fSize, and G4VScoringMesh::sizeIsSet.

Referenced by G4GMocrenFileSceneHandler::AddSolid(), G4ScoreQuantityMessenger::SetNewValue(), and G4ScoringMessenger::SetNewValue().

◆ GetStartAngle()

G4double G4VScoringMesh::GetStartAngle ( ) const

inlineinherited

Definition at line 128 of file G4VScoringMesh.hh.

128{ return fAngle[0]; }

References G4VScoringMesh::fAngle.

Referenced by G4ScoreQuantityMessenger::SetNewValue().

◆ GetTranslation()

G4ThreeVector G4VScoringMesh::GetTranslation ( ) const

inlineinherited

Definition at line 133 of file G4VScoringMesh.hh.

133{ return fCenterPosition; }

References G4VScoringMesh::fCenterPosition.

Referenced by G4GMocrenFileSceneHandler::AddSolid().

◆ GetWorldName()

const G4String & G4VScoringMesh::GetWorldName ( ) const

inlineinherited

Definition at line 91 of file G4VScoringMesh.hh.

91{ return fWorldName; }

References G4VScoringMesh::fWorldName.

Referenced by G4VScoreWriter::DumpAllQuantitiesToFile(), G4VScoreWriter::DumpQuantityToFile(), and G4ScoringMessenger::SetNewValue().

◆ GetXYZ()

void G4ScoringBox::GetXYZ	(	G4int	index,
		G4int	q[3]
	)		const

private

Definition at line 563 of file G4ScoringBox.cc.

{
  q[0] = index / (fNSegment[2] * fNSegment[1]);
  q[1] = (index - q[0] * fNSegment[2] * fNSegment[1]) / fNSegment[2];
  q[2] = index - q[1] * fNSegment[2] - q[0] * fNSegment[2] * fNSegment[1];
}

References G4VScoringMesh::fNSegment.

Referenced by Draw(), and DrawColumn().

◆ IsActive()

G4bool G4VScoringMesh::IsActive ( ) const

inlineinherited

Definition at line 93 of file G4VScoringMesh.hh.

93{ return fActive; }

References G4VScoringMesh::fActive.

Referenced by G4VSceneHandler::AddCompound(), and G4PSHitsModel::DescribeYourselfTo().

◆ IsCurrentPrimitiveScorerNull()

G4bool G4VScoringMesh::IsCurrentPrimitiveScorerNull ( )

inlineinherited

Definition at line 164 of file G4VScoringMesh.hh.

  {
    if(fCurrentPS == nullptr)
      return true;
    else
      return false;
  }

References G4VScoringMesh::fCurrentPS.

Referenced by G4ScoreQuantityMessenger::SetNewValue().

◆ LayeredMassFlg()

G4bool G4VScoringMesh::LayeredMassFlg ( )

inlineinherited

Definition at line 272 of file G4VScoringMesh.hh.

272{ return layeredMassFlg; }

G4VScoringMesh::layeredMassFlg

G4bool layeredMassFlg

Definition: G4VScoringMesh.hh:269

References G4VScoringMesh::layeredMassFlg.

Referenced by G4RunManager::ConstructScoringWorlds(), and G4WorkerRunManager::ConstructScoringWorlds().

◆ List()

void G4ScoringBox::List ( ) const

virtual

Reimplemented from G4VScoringMesh.

Definition at line 238 of file G4ScoringBox.cc.

{
  G4cout << "G4ScoringBox : " << fWorldName << " --- Shape: Box mesh" << G4endl;
  G4cout << " Size (x, y, z): (" << fSize[0] / cm << ", " << fSize[1] / cm
         << ", " << fSize[2] / cm << ") [cm]" << G4endl;
 
  G4VScoringMesh::List();
}

References cm, G4VScoringMesh::fSize, G4VScoringMesh::fWorldName, G4cout, G4endl, and G4VScoringMesh::List().

◆ Merge()

void G4VScoringMesh::Merge ( const G4VScoringMesh * scMesh )

inherited

Definition at line 476 of file G4VScoringMesh.cc.

{
  const MeshScoreMap scMap = scMesh->GetScoreMap();
 
  MeshScoreMap::const_iterator fMapItr = fMap.begin();
  MeshScoreMap::const_iterator mapItr  = scMap.begin();
  for(; fMapItr != fMap.end(); fMapItr++)
  {
    if(verboseLevel > 9)
      G4cout << "G4VScoringMesh::Merge()" << fMapItr->first << G4endl;
    *(fMapItr->second) += *(mapItr->second);
    mapItr++;
  }
}

References G4VScoringMesh::fMap, G4cout, G4endl, G4VScoringMesh::GetScoreMap(), and G4VScoringMesh::verboseLevel.

Referenced by G4ScoringManager::Merge().

◆ ReadyForQuantity()

G4bool G4VScoringMesh::ReadyForQuantity ( ) const

inlineinherited

Definition at line 192 of file G4VScoringMesh.hh.

192{ return (sizeIsSet && nMeshIsSet); }

G4VScoringMesh::nMeshIsSet

G4bool nMeshIsSet

Definition: G4VScoringMesh.hh:217

References G4VScoringMesh::nMeshIsSet, and G4VScoringMesh::sizeIsSet.

Referenced by G4VScoringMesh::SetPrimitiveScorer().

◆ ResetScore()

void G4VScoringMesh::ResetScore ( )

inherited

Definition at line 75 of file G4VScoringMesh.cc.

{
  if(verboseLevel > 9)
    G4cout << "G4VScoringMesh::ResetScore() is called." << G4endl;
  for(auto mp : fMap)
  {
    if(verboseLevel > 9)
      G4cout << "G4VScoringMesh::ResetScore()" << mp.first << G4endl;
    mp.second->clear();
  }
}

References G4VScoringMesh::fMap, G4cout, G4endl, and G4VScoringMesh::verboseLevel.

Referenced by G4VScoringMesh::Construct(), and G4VScoringMesh::WorkerConstruct().

◆ RotateX()

void G4VScoringMesh::RotateX ( G4double delta )

inherited

Definition at line 145 of file G4VScoringMesh.cc.

{
  if(!fRotationMatrix)
    fRotationMatrix = new G4RotationMatrix();
  fRotationMatrix->rotateX(delta);
}

References G4VScoringMesh::fRotationMatrix, and CLHEP::HepRotation::rotateX().

Referenced by G4ScoringMessenger::SetNewValue().

◆ RotateY()

void G4VScoringMesh::RotateY ( G4double delta )

inherited

Definition at line 152 of file G4VScoringMesh.cc.

{
  if(!fRotationMatrix)
    fRotationMatrix = new G4RotationMatrix();
  fRotationMatrix->rotateY(delta);
}

References G4VScoringMesh::fRotationMatrix, and CLHEP::HepRotation::rotateY().

Referenced by G4ScoringMessenger::SetNewValue().

◆ RotateZ()

void G4VScoringMesh::RotateZ ( G4double delta )

inherited

Definition at line 159 of file G4VScoringMesh.cc.

{
  if(!fRotationMatrix)
    fRotationMatrix = new G4RotationMatrix();
  fRotationMatrix->rotateZ(delta);
}

References G4VScoringMesh::fRotationMatrix, and CLHEP::HepRotation::rotateZ().

Referenced by G4ScoringMessenger::SetNewValue().

◆ SetAngles()

void G4VScoringMesh::SetAngles	(	G4double	startAngle,
		G4double	spanAngle
	)

inherited

Definition at line 112 of file G4VScoringMesh.cc.

{
  fAngle[0] = startAngle;
  fAngle[1] = spanAngle;
}

References G4VScoringMesh::fAngle.

Referenced by G4ScoringMessenger::SetNewValue().

◆ SetCenterPosition()

void G4VScoringMesh::SetCenterPosition ( G4double centerPosition[3] )

inherited

Definition at line 118 of file G4VScoringMesh.cc.

{
  fCenterPosition =
    G4ThreeVector(centerPosition[0], centerPosition[1], centerPosition[2]);
}

References G4VScoringMesh::fCenterPosition.

Referenced by G4ScoringMessenger::SetNewValue().

◆ SetCopyNumberLevel()

void G4VScoringMesh::SetCopyNumberLevel ( G4int val )

inlineinherited

Definition at line 262 of file G4VScoringMesh.hh.

262{ copyNumberLevel = val; }

References G4VScoringMesh::copyNumberLevel.

◆ SetCurrentPrimitiveScorer()

void G4VScoringMesh::SetCurrentPrimitiveScorer ( const G4String & name )

inherited

Definition at line 212 of file G4VScoringMesh.cc.

{
  fCurrentPS = GetPrimitiveScorer(name);
  if(!fCurrentPS)
  {
    G4cerr << "ERROR : G4VScoringMesh::SetCurrentPrimitiveScorer() : The "
              "primitive scorer <"
           << name << "> does not found." << G4endl;
  }
}

References G4VScoringMesh::fCurrentPS, G4cerr, G4endl, G4VScoringMesh::GetPrimitiveScorer(), and G4InuclParticleNames::name().

Referenced by G4ScoreQuantityMessenger::SetNewValue().

◆ SetCurrentPSUnit()

void G4VScoringMesh::SetCurrentPSUnit ( const G4String & unit )

inherited

Definition at line 260 of file G4VScoringMesh.cc.

{
  if(!fCurrentPS)
  {
    G4String msg = "ERROR : G4VScoringMesh::GetCurrentPSUnit() : ";
    msg += " Current primitive scorer is null.";
    G4cerr << msg << G4endl;
  }
  else
  {
    fCurrentPS->SetUnit(unit);
  }
}

References G4VScoringMesh::fCurrentPS, G4cerr, G4endl, and G4VPrimitiveScorer::SetUnit().

Referenced by G4ScoreQuantityMessenger::SetNewValue().

◆ SetDrawPSName()

void G4VScoringMesh::SetDrawPSName ( const G4String & psname )

inlineinherited

Definition at line 180 of file G4VScoringMesh.hh.

180{ fDrawPSName = psname; }

References G4VScoringMesh::fDrawPSName.

◆ SetFilter()

void G4VScoringMesh::SetFilter ( G4VSDFilter * filter )

inherited

Definition at line 190 of file G4VScoringMesh.cc.

{
  if(!fCurrentPS)
  {
    G4cerr << "ERROR : G4VScoringMesh::SetSDFilter() : a quantity must be "
              "defined first. This method is ignored."
           << G4endl;
    return;
  }
  if(verboseLevel > 0)
    G4cout << "G4VScoringMesh::SetFilter() : " << filter->GetName()
           << " is set to " << fCurrentPS->GetName() << G4endl;
 
  G4VSDFilter* oldFilter = fCurrentPS->GetFilter();
  if(oldFilter)
  {
    G4cout << "WARNING : G4VScoringMesh::SetFilter() : " << oldFilter->GetName()
           << " is overwritten by " << filter->GetName() << G4endl;
  }
  fCurrentPS->SetFilter(filter);
}

References G4VScoringMesh::fCurrentPS, G4cerr, G4cout, G4endl, G4VPrimitiveScorer::GetFilter(), G4VPrimitiveScorer::GetName(), G4VSDFilter::GetName(), G4VPrimitiveScorer::SetFilter(), and G4VScoringMesh::verboseLevel.

Referenced by G4ScoreQuantityMessenger::FParticleCommand(), G4ScoreQuantityMessenger::FParticleWithEnergyCommand(), and G4ScoreQuantityMessenger::SetNewValue().

◆ SetMeshElementLogical()

void G4VScoringMesh::SetMeshElementLogical ( G4LogicalVolume * val )

inlineinherited

Definition at line 228 of file G4VScoringMesh.hh.

  {
    fMeshElementLogical = val;
  }

References G4VScoringMesh::fMeshElementLogical.

Referenced by G4WorkerRunManager::ConstructScoringWorlds().

◆ SetNullToCurrentPrimitiveScorer()

void G4VScoringMesh::SetNullToCurrentPrimitiveScorer ( )

inlineinherited

Definition at line 186 of file G4VScoringMesh.hh.

186{ fCurrentPS = nullptr; }

References G4VScoringMesh::fCurrentPS.

Referenced by G4ScoreQuantityMessenger::CheckMeshPS().

◆ SetNumberOfSegments()

void G4VScoringMesh::SetNumberOfSegments ( G4int nSegment[3] )

inherited

Definition at line 123 of file G4VScoringMesh.cc.

{
  if(!nMeshIsSet || fShape == MeshShape::realWorldLogVol ||
     fShape == MeshShape::probe)
  {
    for(int i = 0; i < 3; i++)
      fNSegment[i] = nSegment[i];
    nMeshIsSet = true;
  }
  else
  {
    G4String message = "   Number of bins has already been set and it cannot be changed.\n";
    message += "  This method is ignored.";
    G4Exception("G4VScoringMesh::SetNumberOfSegments()",
                "DigiHitsUtilsScoreVScoringMesh000", JustWarning, message);
  }
}

References G4VScoringMesh::fNSegment, G4VScoringMesh::fShape, G4Exception(), JustWarning, G4VScoringMesh::nMeshIsSet, G4VScoringMesh::probe, and G4VScoringMesh::realWorldLogVol.

Referenced by G4ScoringProbe::G4ScoringProbe(), G4ScoringRealWorld::G4ScoringRealWorld(), G4ScoringProbe::LocateProbe(), G4ScoringMessenger::MeshBinCommand(), and G4ScoringRealWorld::SetupGeometry().

◆ SetParallelWorldProcess()

void G4VScoringMesh::SetParallelWorldProcess ( G4ParallelWorldProcess * proc )

inlineinherited

Definition at line 242 of file G4VScoringMesh.hh.

  {
    fParallelWorldProcess = proc;
  }

References G4VScoringMesh::fParallelWorldProcess.

Referenced by G4RunManager::ConstructScoringWorlds(), and G4WorkerRunManager::ConstructScoringWorlds().

◆ SetPrimitiveScorer()

void G4VScoringMesh::SetPrimitiveScorer ( G4VPrimitiveScorer * ps )

inherited

Definition at line 166 of file G4VScoringMesh.cc.

{
  if(!ReadyForQuantity())
  {
    G4cerr << "ERROR : G4VScoringMesh::SetPrimitiveScorer() : "
           << prs->GetName()
           << " does not yet have mesh size or number of bins. Set them first."
           << G4endl << "This Method is ignored." << G4endl;
    return;
  }
  if(verboseLevel > 0)
    G4cout << "G4VScoringMesh::SetPrimitiveScorer() : " << prs->GetName()
           << " is registered."
           << " 3D size: (" << fNSegment[0] << ", " << fNSegment[1] << ", "
           << fNSegment[2] << ")" << G4endl;
 
  prs->SetNijk(fNSegment[0], fNSegment[1], fNSegment[2]);
  fCurrentPS = prs;
  fMFD->RegisterPrimitive(prs);
  G4THitsMap<G4StatDouble>* map =
    new G4THitsMap<G4StatDouble>(fWorldName, prs->GetName());
  fMap[prs->GetName()] = map;
}

References G4VScoringMesh::fCurrentPS, G4VScoringMesh::fMap, G4VScoringMesh::fMFD, G4VScoringMesh::fNSegment, G4VScoringMesh::fWorldName, G4cerr, G4cout, G4endl, G4VPrimitiveScorer::GetName(), anonymous_namespace{G4QuasiElRatios.cc}::map, G4VScoringMesh::ReadyForQuantity(), G4MultiFunctionalDetector::RegisterPrimitive(), G4VPrimitiveScorer::SetNijk(), and G4VScoringMesh::verboseLevel.

Referenced by G4ScoreQuantityMessenger::SetNewValue().

◆ SetSegmentDirection()

void G4ScoringBox::SetSegmentDirection ( G4int dir )

inline

Definition at line 59 of file G4ScoringBox.hh.

59{ fSegmentDirection = dir; }

References fSegmentDirection.

◆ SetSize()

void G4VScoringMesh::SetSize ( G4double size[3] )

inherited

Definition at line 87 of file G4VScoringMesh.cc.

{
  if(!sizeIsSet)
  {
    sizeIsSet = true;
    for(int i = 0; i < 3; i++)
    {
      fSize[i] = size[i];
    }
  }
  else
  {
    G4String message = "   Mesh size has already been set and it cannot be changed.\n";
    message += "  This method is ignored.";
    G4Exception("G4VScoringMesh::SetSize()",
                "DigiHitsUtilsScoreVScoringMesh000", JustWarning, message);
  }
}

References G4VScoringMesh::fSize, G4Exception(), JustWarning, and G4VScoringMesh::sizeIsSet.

Referenced by G4ScoringProbe::G4ScoringProbe(), G4ScoringRealWorld::G4ScoringRealWorld(), and G4ScoringMessenger::SetNewValue().

◆ SetupGeometry()

void G4ScoringBox::SetupGeometry ( G4VPhysicalVolume * fWorldPhys )

protectedvirtual

Implements G4VScoringMesh.

Definition at line 66 of file G4ScoringBox.cc.

{
  if(verboseLevel > 9)
    G4cout << "G4ScoringBox::SetupGeometry() ..." << G4endl;
 
  // World
  G4VPhysicalVolume* scoringWorld = fWorldPhys;
  G4LogicalVolume* worldLogical   = scoringWorld->GetLogicalVolume();
 
  // Scoring Mesh
  if(verboseLevel > 9)
    G4cout << fWorldName << G4endl;
  G4String boxName = fWorldName;
 
  if(verboseLevel > 9)
    G4cout << fSize[0] << ", " << fSize[1] << ", " << fSize[2] << G4endl;
  G4VSolid* boxSolid = new G4Box(boxName + "0", fSize[0], fSize[1], fSize[2]);
  G4LogicalVolume* boxLogical =
    new G4LogicalVolume(boxSolid, 0, boxName + "_0");
  new G4PVPlacement(fRotationMatrix, fCenterPosition, boxLogical, boxName + "0",
                    worldLogical, false, 0);
 
  // G4double fsegment[3][3];
  // G4int segOrder[3];
  // GetSegmentOrder(fSegmentDirection, fNSegment, segOrder, fsegment);
  // EAxis axis[3] = {kXAxis, kYAxis, kZAxis};
 
  G4String layerName[2] = { boxName + "_1", boxName + "_2" };
  G4VSolid* layerSolid[2];
  G4LogicalVolume* layerLogical[2];
 
  //-- fisrt nested layer (replicated to x direction)
  if(verboseLevel > 9)
    G4cout << "layer 1 :" << G4endl;
  layerSolid[0] =
    new G4Box(layerName[0], fSize[0] / fNSegment[0], fSize[1], fSize[2]);
  layerLogical[0] = new G4LogicalVolume(layerSolid[0], 0, layerName[0]);
  if(fNSegment[0] > 1)
  {
    if(verboseLevel > 9)
      G4cout << "G4ScoringBox::Construct() : Replicate to x direction"
             << G4endl;
    if(G4ScoringManager::GetReplicaLevel() > 0)
    {
      new G4PVReplica(layerName[0], layerLogical[0], boxLogical, kXAxis,
                      fNSegment[0], fSize[0] / fNSegment[0] * 2.);
    }
    else
    {
      new G4PVDivision(layerName[0], layerLogical[0], boxLogical, kXAxis,
                       fNSegment[0], 0.);
    }
  }
  else if(fNSegment[0] == 1)
  {
    if(verboseLevel > 9)
      G4cout << "G4ScoringBox::Construct() : Placement" << G4endl;
    new G4PVPlacement(0, G4ThreeVector(0., 0., 0.), layerLogical[0],
                      layerName[0], boxLogical, false, 0);
  }
  else
    G4cerr << "ERROR : G4ScoringBox::SetupGeometry() : invalid parameter ("
           << fNSegment[0] << ") "
           << "in placement of the first nested layer." << G4endl;
 
  if(verboseLevel > 9)
  {
    G4cout << fSize[0] / fNSegment[0] << ", " << fSize[1] << ", " << fSize[2]
           << G4endl;
    G4cout << layerName[0] << ": kXAxis, " << fNSegment[0] << ", "
           << 2. * fSize[0] / fNSegment[0] << G4endl;
  }
 
  // second nested layer (replicated to y direction)
  if(verboseLevel > 9)
    G4cout << "layer 2 :" << G4endl;
  layerSolid[1]   = new G4Box(layerName[1], fSize[0] / fNSegment[0],
                            fSize[1] / fNSegment[1], fSize[2]);
  layerLogical[1] = new G4LogicalVolume(layerSolid[1], 0, layerName[1]);
  if(fNSegment[1] > 1)
  {
    if(verboseLevel > 9)
      G4cout << "G4ScoringBox::Construct() : Replicate to y direction"
             << G4endl;
    if(G4ScoringManager::GetReplicaLevel() > 1)
    {
      new G4PVReplica(layerName[1], layerLogical[1], layerLogical[0], kYAxis,
                      fNSegment[1], fSize[1] / fNSegment[1] * 2.);
    }
    else
    {
      new G4PVDivision(layerName[1], layerLogical[1], layerLogical[0], kYAxis,
                       fNSegment[1], 0.);
    }
  }
  else if(fNSegment[1] == 1)
  {
    if(verboseLevel > 9)
      G4cout << "G4ScoringBox::Construct() : Placement" << G4endl;
    new G4PVPlacement(0, G4ThreeVector(0., 0., 0.), layerLogical[1],
                      layerName[1], layerLogical[0], false, 0);
  }
  else
    G4cerr << "ERROR : G4ScoringBox::SetupGeometry() : invalid parameter ("
           << fNSegment[1] << ") "
           << "in placement of the second nested layer." << G4endl;
 
  if(verboseLevel > 9)
  {
    G4cout << fSize[0] / fNSegment[0] << ", " << fSize[1] / fNSegment[1] << ", "
           << fSize[2] << G4endl;
    G4cout << layerName[1] << ": kYAxis, " << fNSegment[1] << ", "
           << 2. * fSize[1] / fNSegment[1] << G4endl;
  }
 
  // mesh elements (replicated to z direction)
  if(verboseLevel > 9)
    G4cout << "mesh elements :" << G4endl;
  G4String elementName = boxName + "_3";
  G4VSolid* elementSolid =
    new G4Box(elementName, fSize[0] / fNSegment[0], fSize[1] / fNSegment[1],
              fSize[2] / fNSegment[2]);
  fMeshElementLogical = new G4LogicalVolume(elementSolid, 0, elementName);
  if(fNSegment[2] > 1)
  {
    if(verboseLevel > 9)
      G4cout << "G4ScoringBox::Construct() : Replicate to z direction"
             << G4endl;
 
    if(G4ScoringManager::GetReplicaLevel() > 2)
    {
      new G4PVReplica(elementName, fMeshElementLogical, layerLogical[1], kZAxis,
                      fNSegment[2], 2. * fSize[2] / fNSegment[2]);
    }
    else
    {
      new G4PVDivision(elementName, fMeshElementLogical, layerLogical[1],
                       kZAxis, fNSegment[2], 0.);
    }
  }
  else if(fNSegment[2] == 1)
  {
    if(verboseLevel > 9)
      G4cout << "G4ScoringBox::Construct() : Placement" << G4endl;
    new G4PVPlacement(0, G4ThreeVector(0., 0., 0.), fMeshElementLogical,
                      elementName, layerLogical[1], false, 0);
  }
  else
    G4cerr << "ERROR : G4ScoringBox::SetupGeometry() : "
           << "invalid parameter (" << fNSegment[2] << ") "
           << "in mesh element placement." << G4endl;
 
  if(verboseLevel > 9)
  {
    G4cout << fSize[0] / fNSegment[0] << ", " << fSize[1] / fNSegment[1] << ", "
           << fSize[2] / fNSegment[2] << G4endl;
    G4cout << elementName << ": kZAxis, " << fNSegment[2] << ", "
           << 2. * fSize[2] / fNSegment[2] << G4endl;
  }
 
  // set the sensitive detector
  fMeshElementLogical->SetSensitiveDetector(fMFD);
 
  // vis. attributes
  G4VisAttributes* visatt = new G4VisAttributes(G4Colour(.5, .5, .5));
  visatt->SetVisibility(false);
  layerLogical[0]->SetVisAttributes(visatt);
  layerLogical[1]->SetVisAttributes(visatt);
  visatt->SetVisibility(true);
  fMeshElementLogical->SetVisAttributes(visatt);
}

References G4VScoringMesh::fCenterPosition, G4VScoringMesh::fMeshElementLogical, G4VScoringMesh::fMFD, G4VScoringMesh::fNSegment, G4VScoringMesh::fRotationMatrix, G4VScoringMesh::fSize, G4VScoringMesh::fWorldName, G4cerr, G4cout, G4endl, G4VPhysicalVolume::GetLogicalVolume(), G4ScoringManager::GetReplicaLevel(), kXAxis, kYAxis, kZAxis, G4LogicalVolume::SetSensitiveDetector(), G4LogicalVolume::SetVisAttributes(), G4VisAttributes::SetVisibility(), and G4VScoringMesh::verboseLevel.

◆ SetVerboseLevel()

void G4VScoringMesh::SetVerboseLevel ( G4int vl )

inlineinherited

Definition at line 188 of file G4VScoringMesh.hh.

188{ verboseLevel = vl; }

References G4VScoringMesh::verboseLevel.

Referenced by G4ScoringManager::RegisterScoringMesh().

◆ WorkerConstruct()

void G4VScoringMesh::WorkerConstruct ( G4VPhysicalVolume * fWorldPhys )

virtualinherited

Definition at line 454 of file G4VScoringMesh.cc.

{
  if(fConstructed)
  {
    if(fGeometryHasBeenDestroyed)
    {
      fMeshElementLogical->SetSensitiveDetector(fMFD);
      fGeometryHasBeenDestroyed = false;
    }
 
    if(verboseLevel > 0)
      G4cout << fWorldPhys->GetName() << " --- All quantities are reset."
             << G4endl;
    ResetScore();
  }
  else
  {
    fConstructed = true;
    fMeshElementLogical->SetSensitiveDetector(fMFD);
  }
}

References G4VScoringMesh::fConstructed, G4VScoringMesh::fGeometryHasBeenDestroyed, G4VScoringMesh::fMeshElementLogical, G4VScoringMesh::fMFD, G4cout, G4endl, G4VPhysicalVolume::GetName(), G4VScoringMesh::ResetScore(), G4LogicalVolume::SetSensitiveDetector(), and G4VScoringMesh::verboseLevel.

Referenced by G4WorkerRunManager::ConstructScoringWorlds().

Field Documentation

◆ copyNumberLevel

G4int G4VScoringMesh::copyNumberLevel

protectedinherited

Definition at line 257 of file G4VScoringMesh.hh.

Referenced by G4VScoringMesh::GetCopyNumberLevel(), and G4VScoringMesh::SetCopyNumberLevel().

◆ fActive

G4bool G4VScoringMesh::fActive

protectedinherited

Definition at line 202 of file G4VScoringMesh.hh.

Referenced by G4VScoringMesh::Activate(), and G4VScoringMesh::IsActive().

◆ fAngle

G4double G4VScoringMesh::fAngle[2]

protectedinherited

Definition at line 206 of file G4VScoringMesh.hh.

Referenced by G4ScoringCylinder::Draw(), G4ScoringCylinder::DrawColumn(), G4VScoringMesh::G4VScoringMesh(), G4VScoringMesh::GetAngleSpan(), G4VScoringMesh::GetStartAngle(), G4ScoringCylinder::List(), G4VScoringMesh::SetAngles(), and G4ScoringCylinder::SetupGeometry().

◆ fCenterPosition

G4ThreeVector G4VScoringMesh::fCenterPosition

protectedinherited

Definition at line 207 of file G4VScoringMesh.hh.

Referenced by Draw(), G4ScoringCylinder::Draw(), DrawColumn(), G4ScoringCylinder::DrawColumn(), G4VScoringMesh::GetTranslation(), G4VScoringMesh::List(), G4VScoringMesh::SetCenterPosition(), SetupGeometry(), and G4ScoringCylinder::SetupGeometry().

◆ fConstructed

G4bool G4VScoringMesh::fConstructed

protectedinherited

Definition at line 201 of file G4VScoringMesh.hh.

Referenced by G4VScoringMesh::Construct(), and G4VScoringMesh::WorkerConstruct().

◆ fCurrentPS

G4VPrimitiveScorer* G4VScoringMesh::fCurrentPS

protectedinherited

Definition at line 200 of file G4VScoringMesh.hh.

Referenced by G4VScoringMesh::GetCurrentPSUnit(), G4VScoringMesh::IsCurrentPrimitiveScorerNull(), G4VScoringMesh::SetCurrentPrimitiveScorer(), G4VScoringMesh::SetCurrentPSUnit(), G4VScoringMesh::SetFilter(), G4VScoringMesh::SetNullToCurrentPrimitiveScorer(), and G4VScoringMesh::SetPrimitiveScorer().

◆ fDivisionAxisNames

G4String G4VScoringMesh::fDivisionAxisNames[3]

protectedinherited

Definition at line 223 of file G4VScoringMesh.hh.

Referenced by G4ScoringBox(), G4ScoringCylinder::G4ScoringCylinder(), G4VScoringMesh::G4VScoringMesh(), and G4VScoringMesh::GetDivisionAxisNames().

◆ fDrawPSName

G4String G4VScoringMesh::fDrawPSName

protectedinherited

Definition at line 221 of file G4VScoringMesh.hh.

Referenced by Draw(), G4ScoringCylinder::Draw(), DrawColumn(), G4ScoringCylinder::DrawColumn(), G4VScoringMesh::DrawMesh(), and G4VScoringMesh::SetDrawPSName().

◆ fDrawUnit

G4String G4VScoringMesh::fDrawUnit

protectedinherited

Definition at line 219 of file G4VScoringMesh.hh.

Referenced by Draw(), G4ScoringCylinder::Draw(), DrawColumn(), G4ScoringCylinder::DrawColumn(), and G4VScoringMesh::DrawMesh().

◆ fDrawUnitValue

G4double G4VScoringMesh::fDrawUnitValue

protectedinherited

Definition at line 220 of file G4VScoringMesh.hh.

Referenced by Draw(), G4ScoringCylinder::Draw(), DrawColumn(), G4ScoringCylinder::DrawColumn(), and G4VScoringMesh::DrawMesh().

◆ fGeometryHasBeenDestroyed

G4bool G4VScoringMesh::fGeometryHasBeenDestroyed

protectedinherited

Definition at line 239 of file G4VScoringMesh.hh.

Referenced by G4VScoringMesh::Construct(), G4VScoringMesh::GeometryHasBeenDestroyed(), and G4VScoringMesh::WorkerConstruct().

◆ fMap

MeshScoreMap G4VScoringMesh::fMap

protectedinherited

Definition at line 211 of file G4VScoringMesh.hh.

Referenced by G4VScoringMesh::Accumulate(), G4VScoringMesh::DrawMesh(), G4VScoringMesh::Dump(), G4VScoringMesh::FindPrimitiveScorer(), G4VScoringMesh::GetPSUnit(), G4VScoringMesh::GetPSUnitValue(), G4VScoringMesh::GetScoreMap(), G4VScoringMesh::Merge(), G4VScoringMesh::ResetScore(), and G4VScoringMesh::SetPrimitiveScorer().

◆ fMeshElementLogical

G4LogicalVolume* G4VScoringMesh::fMeshElementLogical

protectedinherited

Definition at line 225 of file G4VScoringMesh.hh.

Referenced by G4VScoringMesh::GeometryHasBeenDestroyed(), G4VScoringMesh::GetMeshElementLogical(), G4VScoringMesh::SetMeshElementLogical(), G4ScoringProbe::SetupGeometry(), G4ScoringRealWorld::SetupGeometry(), SetupGeometry(), G4ScoringCylinder::SetupGeometry(), and G4VScoringMesh::WorkerConstruct().

◆ fMFD

G4MultiFunctionalDetector* G4VScoringMesh::fMFD

protectedinherited

Definition at line 212 of file G4VScoringMesh.hh.

Referenced by G4VScoringMesh::G4VScoringMesh(), G4VScoringMesh::GetPrimitiveScorer(), G4VScoringMesh::List(), G4VScoringMesh::SetPrimitiveScorer(), G4ScoringProbe::SetupGeometry(), G4ScoringRealWorld::SetupGeometry(), SetupGeometry(), G4ScoringCylinder::SetupGeometry(), and G4VScoringMesh::WorkerConstruct().

◆ fNSegment

G4int G4VScoringMesh::fNSegment[3]

protectedinherited

Definition at line 209 of file G4VScoringMesh.hh.

Referenced by Draw(), G4ScoringCylinder::Draw(), DrawColumn(), G4ScoringCylinder::DrawColumn(), G4VScoringMesh::G4VScoringMesh(), GetIndex(), G4VScoringMesh::GetNumberOfSegments(), GetReplicaPosition(), G4ScoringCylinder::GetRZPhi(), GetXYZ(), G4VScoringMesh::List(), G4VScoringMesh::SetNumberOfSegments(), G4VScoringMesh::SetPrimitiveScorer(), SetupGeometry(), and G4ScoringCylinder::SetupGeometry().

◆ fParallelWorldProcess

G4ParallelWorldProcess* G4VScoringMesh::fParallelWorldProcess

protectedinherited

Definition at line 238 of file G4VScoringMesh.hh.

Referenced by G4VScoringMesh::GetParallelWorldProcess(), and G4VScoringMesh::SetParallelWorldProcess().

◆ fRotationMatrix

G4RotationMatrix* G4VScoringMesh::fRotationMatrix

protectedinherited

Definition at line 208 of file G4VScoringMesh.hh.

Referenced by Draw(), G4ScoringCylinder::Draw(), DrawColumn(), G4ScoringCylinder::DrawColumn(), G4VScoringMesh::GetRotationMatrix(), G4VScoringMesh::List(), G4VScoringMesh::RotateX(), G4VScoringMesh::RotateY(), G4VScoringMesh::RotateZ(), SetupGeometry(), and G4ScoringCylinder::SetupGeometry().

◆ fSegmentDirection

G4int G4ScoringBox::fSegmentDirection

private

Definition at line 70 of file G4ScoringBox.hh.

Referenced by SetSegmentDirection().

◆ fShape

MeshShape G4VScoringMesh::fShape

protectedinherited

Definition at line 203 of file G4VScoringMesh.hh.

Referenced by G4ScoringBox(), G4ScoringCylinder::G4ScoringCylinder(), G4ScoringProbe::G4ScoringProbe(), G4ScoringRealWorld::G4ScoringRealWorld(), G4VScoringMesh::GetShape(), and G4VScoringMesh::SetNumberOfSegments().

◆ fSize

G4double G4VScoringMesh::fSize[3]

protectedinherited

Definition at line 205 of file G4VScoringMesh.hh.

Referenced by Draw(), G4ScoringCylinder::Draw(), DrawColumn(), G4ScoringCylinder::DrawColumn(), G4VScoringMesh::G4VScoringMesh(), GetReplicaPosition(), G4VScoringMesh::GetSize(), List(), G4ScoringCylinder::List(), G4ScoringCylinder::SetRMax(), G4ScoringCylinder::SetRMin(), G4VScoringMesh::SetSize(), SetupGeometry(), G4ScoringCylinder::SetupGeometry(), and G4ScoringCylinder::SetZSize().

◆ fWorldName

G4String G4VScoringMesh::fWorldName

protectedinherited

Definition at line 199 of file G4VScoringMesh.hh.

Referenced by G4VScoringMesh::Construct(), G4VScoringMesh::Dump(), G4VScoringMesh::GetWorldName(), List(), G4ScoringCylinder::List(), G4VScoringMesh::SetPrimitiveScorer(), SetupGeometry(), and G4ScoringCylinder::SetupGeometry().

◆ layeredMassFlg

G4bool G4VScoringMesh::layeredMassFlg

protectedinherited

Definition at line 269 of file G4VScoringMesh.hh.

Referenced by G4VScoringMesh::LayeredMassFlg(), and G4ScoringProbe::SetMaterial().

◆ nMeshIsSet

G4bool G4VScoringMesh::nMeshIsSet

protectedinherited

Definition at line 217 of file G4VScoringMesh.hh.

Referenced by G4VScoringMesh::ReadyForQuantity(), and G4VScoringMesh::SetNumberOfSegments().

◆ sizeIsSet

G4bool G4VScoringMesh::sizeIsSet

protectedinherited

Definition at line 216 of file G4VScoringMesh.hh.

Referenced by G4VScoringMesh::GetSize(), G4VScoringMesh::ReadyForQuantity(), and G4VScoringMesh::SetSize().

◆ verboseLevel

G4int G4VScoringMesh::verboseLevel

protectedinherited

Definition at line 214 of file G4VScoringMesh.hh.

Referenced by G4VScoringMesh::Accumulate(), G4VScoringMesh::Construct(), G4VScoringMesh::Merge(), G4VScoringMesh::ResetScore(), G4VScoringMesh::SetFilter(), G4VScoringMesh::SetPrimitiveScorer(), SetupGeometry(), G4ScoringCylinder::SetupGeometry(), G4VScoringMesh::SetVerboseLevel(), and G4VScoringMesh::WorkerConstruct().

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

source/digits_hits/utils/include/G4ScoringBox.hh
source/digits_hits/utils/src/G4ScoringBox.cc

Protected Attributes
G4int	copyNumberLevel

G4bool	fActive

G4double	fAngle [2]

G4ThreeVector	fCenterPosition

G4bool	fConstructed

G4VPrimitiveScorer *	fCurrentPS

G4String	fDivisionAxisNames [3]

G4String	fDrawPSName

G4String	fDrawUnit

G4double	fDrawUnitValue

G4bool	fGeometryHasBeenDestroyed

MeshScoreMap	fMap

G4LogicalVolume *	fMeshElementLogical

G4MultiFunctionalDetector *	fMFD

G4int	fNSegment [3]

G4ParallelWorldProcess *	fParallelWorldProcess

G4RotationMatrix *	fRotationMatrix

MeshShape	fShape

G4double	fSize [3]

G4String	fWorldName

G4bool	layeredMassFlg

G4bool	nMeshIsSet

G4bool	sizeIsSet

G4int	verboseLevel

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ EventScore

◆ MeshScoreMap

◆ RunScore

Member Enumeration Documentation

◆ MeshShape

Constructor & Destructor Documentation

◆ G4ScoringBox()

◆ ~G4ScoringBox()

Member Function Documentation

◆ Accumulate() [1/2]

◆ Accumulate() [2/2]

◆ Activate()

◆ Construct()

◆ Draw()

◆ DrawColumn()

◆ DrawMesh() [1/2]

◆ DrawMesh() [2/2]

◆ Dump()

◆ FindPrimitiveScorer()

◆ GeometryHasBeenDestroyed()

◆ GetAngleSpan()

◆ GetCopyNumberLevel()

◆ GetCurrentPSUnit()

◆ GetDivisionAxisNames()

◆ GetIndex()

◆ GetMeshElementLogical()

◆ GetNumberOfSegments()

◆ GetParallelWorldProcess()

◆ GetPrimitiveScorer()

◆ GetPSUnit()

◆ GetPSUnitValue()

◆ GetReplicaPosition()

◆ GetRotationMatrix()

◆ GetScoreMap()

◆ GetShape()

◆ GetSize()

◆ GetStartAngle()

◆ GetTranslation()

◆ GetWorldName()

◆ GetXYZ()

◆ IsActive()

◆ IsCurrentPrimitiveScorerNull()

◆ LayeredMassFlg()

◆ List()

◆ Merge()

◆ ReadyForQuantity()

◆ ResetScore()

◆ RotateX()

◆ RotateY()

◆ RotateZ()

◆ SetAngles()

◆ SetCenterPosition()

◆ SetCopyNumberLevel()

◆ SetCurrentPrimitiveScorer()

◆ SetCurrentPSUnit()

◆ SetDrawPSName()

◆ SetFilter()

◆ SetMeshElementLogical()

◆ SetNullToCurrentPrimitiveScorer()

◆ SetNumberOfSegments()

◆ SetParallelWorldProcess()

◆ SetPrimitiveScorer()

◆ SetSegmentDirection()

◆ SetSize()

◆ SetupGeometry()

◆ SetVerboseLevel()

◆ WorkerConstruct()

Field Documentation

◆ copyNumberLevel

◆ fActive

◆ fAngle

◆ fCenterPosition