#include <G4ScoringCylinder.hh>

Inheritance diagram for G4ScoringCylinder:

Public Types
using	EventScore = G4THitsMap< G4double >

enum	IDX { IZ , IPHI , IR }

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)

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

virtual 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)

	G4ScoringCylinder (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

void	GetRZPhi (G4int index, G4int q[3]) 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 ()

virtual void	List () const

void	Merge (const G4VScoringMesh *scMesh)

G4bool	ReadyForQuantity () const

void	RegisterPrimitives (std::vector< G4VPrimitiveScorer * > &vps)

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	SetRMax (G4double rMax)

void	SetRMin (G4double rMin)

void	SetSize (G4double size[3])

void	SetVerboseLevel (G4int vl)

void	SetZSize (G4double zSize)

virtual void	WorkerConstruct (G4VPhysicalVolume *fWorldPhys)

	~G4ScoringCylinder ()

Protected Member Functions
virtual void	SetupGeometry (G4VPhysicalVolume *fWorldPhys)

Private Member Functions
void	DumpLogVols (G4int)

void	DumpPhysVols (G4int)

void	DumpSolids (G4int)

void	DumpVolumes ()

Detailed Description

Definition at line 40 of file G4ScoringCylinder.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

◆ IDX

enum G4ScoringCylinder::IDX

Enumerator
IZ
IPHI
IR

Definition at line 69 of file G4ScoringCylinder.hh.

  {
    IZ,
    IPHI,
    IR
  };

◆ 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

◆ G4ScoringCylinder()

G4ScoringCylinder::G4ScoringCylinder ( G4String wName )

Definition at line 55 of file G4ScoringCylinder.cc.

  : G4VScoringMesh(wName)
{
  fShape = MeshShape::cylinder;
 
  fDivisionAxisNames[0] = "Z";
  fDivisionAxisNames[1] = "PHI";
  fDivisionAxisNames[2] = "R";
}

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

◆ ~G4ScoringCylinder()

G4ScoringCylinder::~G4ScoringCylinder ( )

Definition at line 65 of file G4ScoringCylinder.cc.

65{ ; }

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 G4ScoringCylinder::Draw	(	RunScore *	map,
		G4VScoreColorMap *	colorMap,
		G4int	axflg = `111`
	)

virtual

Implements G4VScoringMesh.

Definition at line 259 of file G4ScoringCylinder.cc.

{
  G4VVisManager* pVisManager = G4VVisManager::GetConcreteInstance();
  if(pVisManager)
  {
    // cell vectors
    std::vector<double> ephi;
    for(int phi = 0; phi < fNSegment[IPHI]; phi++)
      ephi.push_back(0.);
    //-
    std::vector<std::vector<double>> zphicell;  // zphicell[Z][PHI]
    for(int z = 0; z < fNSegment[IZ]; z++)
      zphicell.push_back(ephi);
    //-
    std::vector<std::vector<double>> rphicell;  // rphicell[R][PHI]
    for(int r = 0; r < fNSegment[IR]; r++)
      rphicell.push_back(ephi);
 
    // projections
    G4int q[3];
    std::map<G4int, G4StatDouble*>::iterator itr = map->GetMap()->begin();
    for(; itr != map->GetMap()->end(); itr++)
    {
      if(itr->first < 0)
      {
        G4cout << itr->first << G4endl;
        continue;
      }
      GetRZPhi(itr->first, q);
 
      zphicell[q[IZ]][q[IPHI]] += (itr->second->sum_wx()) / fDrawUnitValue;
      rphicell[q[IR]][q[IPHI]] += (itr->second->sum_wx()) / fDrawUnitValue;
    }
 
    // search min./max. values
    G4double zphimin = DBL_MAX, rphimin = DBL_MAX;
    G4double zphimax = 0., rphimax = 0.;
    for(int iphi = 0; iphi < fNSegment[IPHI]; iphi++)
    {
      for(int iz = 0; iz < fNSegment[IZ]; iz++)
      {
        if(zphimin > zphicell[iz][iphi])
          zphimin = zphicell[iz][iphi];
        if(zphimax < zphicell[iz][iphi])
          zphimax = zphicell[iz][iphi];
      }
      for(int ir = 0; ir < fNSegment[IR]; ir++)
      {
        if(rphimin > rphicell[ir][iphi])
          rphimin = rphicell[ir][iphi];
        if(rphimax < rphicell[ir][iphi])
          rphimax = rphicell[ir][iphi];
      }
    }
 
    G4VisAttributes att;
    att.SetForceSolid(true);
    att.SetForceAuxEdgeVisible(true);
 
    G4Scale3D scale;
    if(axflg / 100 == 1)
    {
      // rz plane
    }
    axflg = axflg % 100;
    if(axflg / 10 == 1)
    {
      pVisManager->BeginDraw();
 
      // z-phi plane
      if(colorMap->IfFloatMinMax())
      {
        colorMap->SetMinMax(zphimin, zphimax);
      }
 
      G4double zhalf = fSize[2] / fNSegment[IZ];
      for(int phi = 0; phi < fNSegment[IPHI]; phi++)
      {
        for(int z = 0; z < fNSegment[IZ]; z++)
        {
          //-
          G4double angle = fAngle[0] + fAngle[1] / fNSegment[IPHI] * phi;
          G4double dphi  = fAngle[1] / fNSegment[IPHI];
          G4Tubs cylinder(
            "z-phi",                    // name
            fSize[1] * 0.99, fSize[1],  // inner radius, outer radius
            zhalf,                      // half length in z
            angle, dphi * 0.99999);     // starting phi angle, delta angle
          //-
          G4ThreeVector zpos(
            0., 0., -fSize[2] + fSize[2] / fNSegment[IZ] * (1 + 2. * z));
          G4Transform3D trans;
          if(fRotationMatrix)
          {
            trans =
              G4Rotate3D(*fRotationMatrix).inverse() * G4Translate3D(zpos);
            trans = G4Translate3D(fCenterPosition) * trans;
          }
          else
          {
            trans = G4Translate3D(zpos) * G4Translate3D(fCenterPosition);
          }
          G4double c[4];
          colorMap->GetMapColor(zphicell[z][phi], c);
          att.SetColour(c[0], c[1], c[2]);  //, c[3]);
          //-
          G4Polyhedron* poly = cylinder.GetPolyhedron();
          poly->Transform(trans);
          poly->SetVisAttributes(att);
          pVisManager->Draw(*poly);
        }
      }
      pVisManager->EndDraw();
    }
    axflg = axflg % 10;
    if(axflg == 1)
    {
      pVisManager->BeginDraw();
 
      // r-phi plane
      if(colorMap->IfFloatMinMax())
      {
        colorMap->SetMinMax(rphimin, rphimax);
      }
 
      G4double rsize = (fSize[1] - fSize[0]) / fNSegment[IR];
      for(int phi = 0; phi < fNSegment[IPHI]; phi++)
      {
        for(int r = 0; r < fNSegment[IR]; r++)
        {
          G4double rs[2] = { fSize[0] + rsize * r, fSize[0] + rsize * (r + 1) };
          G4double angle = fAngle[0] + fAngle[1] / fNSegment[IPHI] * phi;
          G4double dphi  = fAngle[1] / fNSegment[IPHI];
          G4Tubs cylindern("z-phi", rs[0], rs[1], 0.001, angle, dphi * 0.99999);
          G4Tubs cylinderp = cylindern;
 
          G4ThreeVector zposn(0., 0., -fSize[2]);
          G4ThreeVector zposp(0., 0., fSize[2]);
          G4Transform3D transn, transp;
          if(fRotationMatrix)
          {
            transn =
              G4Rotate3D(*fRotationMatrix).inverse() * G4Translate3D(zposn);
            transn = G4Translate3D(fCenterPosition) * transn;
            transp =
              G4Rotate3D(*fRotationMatrix).inverse() * G4Translate3D(zposp);
            transp = G4Translate3D(fCenterPosition) * transp;
          }
          else
          {
            transn = G4Translate3D(zposn) * G4Translate3D(fCenterPosition);
            transp = G4Translate3D(zposp) * G4Translate3D(fCenterPosition);
          }
          G4double c[4];
          colorMap->GetMapColor(rphicell[r][phi], c);
          att.SetColour(c[0], c[1], c[2]);  //, c[3]);
 
          G4Polyhedron* polyn = cylindern.GetPolyhedron();
          polyn->Transform(transn);
          polyn->SetVisAttributes(att);
          pVisManager->Draw(*polyn);
 
          G4Polyhedron* polyp = cylinderp.GetPolyhedron();
          polyp->Transform(transp);
          polyp->SetVisAttributes(att);
          pVisManager->Draw(*polyp);
        }
      }
 
      pVisManager->EndDraw();
    }
 
    colorMap->SetPSUnit(fDrawUnit);
    colorMap->SetPSName(fDrawPSName);
    colorMap->DrawColorChart();
  }
}

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

◆ DrawColumn()

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

virtual

Implements G4VScoringMesh.

Definition at line 438 of file G4ScoringCylinder.cc.

{
  G4int projAxis = 0;
  switch(idxProj)
  {
    case 0:
      projAxis = IR;
      break;
    case 1:
      projAxis = IZ;
      break;
    case 2:
      projAxis = IPHI;
      break;
  }
 
  if(idxColumn < 0 || idxColumn >= fNSegment[projAxis])
  {
    G4cerr << "Warning : Column number " << idxColumn
           << " is out of scoring mesh [0," << fNSegment[projAxis] - 1
           << "]. Method ignored." << G4endl;
    return;
  }
  G4VVisManager* pVisManager = G4VVisManager::GetConcreteInstance();
  if(pVisManager)
  {
    // cell vectors
    std::vector<std::vector<std::vector<double>>> cell;  // cell[R][Z][PHI]
    std::vector<double> ephi;
    for(int phi = 0; phi < fNSegment[IPHI]; phi++)
      ephi.push_back(0.);
    std::vector<std::vector<double>> ezphi;
    for(int z = 0; z < fNSegment[IZ]; z++)
      ezphi.push_back(ephi);
    for(int r = 0; r < fNSegment[IR]; r++)
      cell.push_back(ezphi);
 
    std::vector<std::vector<double>> rzcell;  // rzcell[R][Z]
    std::vector<double> ez;
    for(int z = 0; z < fNSegment[IZ]; z++)
      ez.push_back(0.);
    for(int r = 0; r < fNSegment[IR]; r++)
      rzcell.push_back(ez);
 
    std::vector<std::vector<double>> zphicell;  // zphicell[Z][PHI]
    for(int z = 0; z < fNSegment[IZ]; z++)
      zphicell.push_back(ephi);
 
    std::vector<std::vector<double>> rphicell;  // rphicell[R][PHI]
    for(int r = 0; r < fNSegment[IR]; r++)
      rphicell.push_back(ephi);
 
    // projections
    G4int q[3];
    std::map<G4int, G4StatDouble*>::iterator itr = map->GetMap()->begin();
    for(; itr != map->GetMap()->end(); itr++)
    {
      if(itr->first < 0)
      {
        G4cout << itr->first << G4endl;
        continue;
      }
      GetRZPhi(itr->first, q);
 
      if(projAxis == IR && q[IR] == idxColumn)
      {  // zphi plane
        zphicell[q[IZ]][q[IPHI]] += (itr->second->sum_wx()) / fDrawUnitValue;
      }
      if(projAxis == IZ && q[IZ] == idxColumn)
      {  // rphi plane
        rphicell[q[IR]][q[IPHI]] += (itr->second->sum_wx()) / fDrawUnitValue;
      }
      if(projAxis == IPHI && q[IPHI] == idxColumn)
      {  // rz plane
        rzcell[q[IR]][q[IZ]] += (itr->second->sum_wx()) / fDrawUnitValue;
      }
    }
 
    // search min./max. values
    G4double rzmin = DBL_MAX, zphimin = DBL_MAX, rphimin = DBL_MAX;
    G4double rzmax = 0., zphimax = 0., rphimax = 0.;
    for(int r = 0; r < fNSegment[IR]; r++)
    {
      for(int phi = 0; phi < fNSegment[IPHI]; phi++)
      {
        if(rphimin > rphicell[r][phi])
          rphimin = rphicell[r][phi];
        if(rphimax < rphicell[r][phi])
          rphimax = rphicell[r][phi];
      }
      for(int z = 0; z < fNSegment[IZ]; z++)
      {
        if(rzmin > rzcell[r][z])
          rzmin = rzcell[r][z];
        if(rzmax < rzcell[r][z])
          rzmax = rzcell[r][z];
      }
    }
    for(int z = 0; z < fNSegment[IZ]; z++)
    {
      for(int phi = 0; phi < fNSegment[IPHI]; phi++)
      {
        if(zphimin > zphicell[z][phi])
          zphimin = zphicell[z][phi];
        if(zphimax < zphicell[z][phi])
          zphimax = zphicell[z][phi];
      }
    }
 
    G4VisAttributes att;
    att.SetForceSolid(true);
    att.SetForceAuxEdgeVisible(true);
 
    pVisManager->BeginDraw();
 
    G4Scale3D scale;
    // z-phi plane
    if(projAxis == IR)
    {
      if(colorMap->IfFloatMinMax())
      {
        colorMap->SetMinMax(zphimin, zphimax);
      }
 
      G4double zhalf    = fSize[2] / fNSegment[IZ];
      G4double rsize[2] = {
        fSize[0] + (fSize[1] - fSize[0]) / fNSegment[IR] * idxColumn,
        fSize[0] + (fSize[1] - fSize[0]) / fNSegment[IR] * (idxColumn + 1)
      };
      for(int phi = 0; phi < fNSegment[IPHI]; phi++)
      {
        for(int z = 0; z < fNSegment[IZ]; z++)
        {
          G4double angle = fAngle[0] + fAngle[1] / fNSegment[IPHI] * phi;
          G4double dphi  = fAngle[1] / fNSegment[IPHI];
          G4Tubs cylinder("z-phi", rsize[0], rsize[1], zhalf, angle,
                          dphi * 0.99999);
 
          G4ThreeVector zpos(
            0., 0., -fSize[2] + fSize[2] / fNSegment[IZ] * (1 + 2. * z));
          G4Transform3D trans;
          if(fRotationMatrix)
          {
            trans =
              G4Rotate3D(*fRotationMatrix).inverse() * G4Translate3D(zpos);
            trans = G4Translate3D(fCenterPosition) * trans;
          }
          else
          {
            trans = G4Translate3D(zpos) * G4Translate3D(fCenterPosition);
          }
          G4double c[4];
          colorMap->GetMapColor(zphicell[z][phi], c);
          att.SetColour(c[0], c[1], c[2]);  //, c[3]);
 
          G4Polyhedron* poly = cylinder.GetPolyhedron();
          poly->Transform(trans);
          poly->SetVisAttributes(att);
          pVisManager->Draw(*poly);
        }
      }
 
      // r-phi plane
    }
    else if(projAxis == IZ)
    {
      if(colorMap->IfFloatMinMax())
      {
        colorMap->SetMinMax(rphimin, rphimax);
      }
 
      G4double rsize = (fSize[1] - fSize[0]) / fNSegment[IR];
      for(int phi = 0; phi < fNSegment[IPHI]; phi++)
      {
        for(int r = 0; r < fNSegment[IR]; r++)
        {
          G4double rs[2] = { fSize[0] + rsize * r, fSize[0] + rsize * (r + 1) };
          G4double angle = fAngle[0] + fAngle[1] / fNSegment[IPHI] * phi;
          G4double dz    = fSize[2] / fNSegment[IZ];
          G4double dphi  = fAngle[1] / fNSegment[IPHI];
          G4Tubs cylinder("r-phi", rs[0], rs[1], dz, angle, dphi * 0.99999);
          G4ThreeVector zpos(
            0., 0., -fSize[2] + fSize[2] / fNSegment[IZ] * (idxColumn * 2 + 1));
          G4Transform3D trans;
          if(fRotationMatrix)
          {
            trans =
              G4Rotate3D(*fRotationMatrix).inverse() * G4Translate3D(zpos);
            trans = G4Translate3D(fCenterPosition) * trans;
          }
          else
          {
            trans = G4Translate3D(zpos) * G4Translate3D(fCenterPosition);
          }
          G4double c[4];
          colorMap->GetMapColor(rphicell[r][phi], c);
          att.SetColour(c[0], c[1], c[2]);  //, c[3]);
 
          G4Polyhedron* poly = cylinder.GetPolyhedron();
          poly->Transform(trans);
          poly->SetVisAttributes(att);
          pVisManager->Draw(*poly);
        }
      }
 
      // r-z plane
    }
    else if(projAxis == IPHI)
    {
      if(colorMap->IfFloatMinMax())
      {
        colorMap->SetMinMax(rzmin, rzmax);
      }
 
      G4double rsize = (fSize[1] - fSize[0]) / fNSegment[IR];
      G4double zhalf = fSize[2] / fNSegment[IZ];
      G4double angle = fAngle[0] + fAngle[1] / fNSegment[IPHI] * idxColumn;
      G4double dphi  = fAngle[1] / fNSegment[IPHI];
      for(int z = 0; z < fNSegment[IZ]; z++)
      {
        for(int r = 0; r < fNSegment[IR]; r++)
        {
          G4double rs[2] = { fSize[0] + rsize * r, fSize[0] + rsize * (r + 1) };
          G4Tubs cylinder("z-phi", rs[0], rs[1], zhalf, angle, dphi);
 
          G4ThreeVector zpos(
            0., 0., -fSize[2] + fSize[2] / fNSegment[IZ] * (2. * z + 1));
          G4Transform3D trans;
          if(fRotationMatrix)
          {
            trans =
              G4Rotate3D(*fRotationMatrix).inverse() * G4Translate3D(zpos);
            trans = G4Translate3D(fCenterPosition) * trans;
          }
          else
          {
            trans = G4Translate3D(zpos) * G4Translate3D(fCenterPosition);
          }
          G4double c[4];
          colorMap->GetMapColor(rzcell[r][z], c);
          att.SetColour(c[0], c[1], c[2]);  //, c[3]);
 
          G4Polyhedron* poly = cylinder.GetPolyhedron();
          poly->Transform(trans);
          poly->SetVisAttributes(att);
          pVisManager->Draw(*poly);
        }
      }
    }
    pVisManager->EndDraw();
  }
 
  colorMap->SetPSUnit(fDrawUnit);
  colorMap->SetPSName(fDrawPSName);
  colorMap->DrawColorChart();
}

References angle, G4VVisManager::BeginDraw(), DBL_MAX, G4VVisManager::Draw(), G4VScoreColorMap::DrawColorChart(), G4VVisManager::EndDraw(), G4VScoringMesh::fAngle, G4VScoringMesh::fCenterPosition, G4VScoringMesh::fDrawPSName, G4VScoringMesh::fDrawUnit, G4VScoringMesh::fDrawUnitValue, G4VScoringMesh::fNSegment, G4VScoringMesh::fRotationMatrix, G4VScoringMesh::fSize, G4cerr, G4cout, G4endl, G4VVisManager::GetConcreteInstance(), G4VScoreColorMap::GetMapColor(), G4CSGSolid::GetPolyhedron(), GetRZPhi(), G4VScoreColorMap::IfFloatMinMax(), HepGeom::Transform3D::inverse(), IPHI, IR, IZ, anonymous_namespace{G4QuasiElRatios.cc}::map, 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.

◆ DumpLogVols()

void G4ScoringCylinder::DumpLogVols ( G4int lvl )

private

Definition at line 753 of file G4ScoringCylinder.cc.

{
  G4cout << "*********** List of registered logical volumes *************"
         << G4endl;
  auto store = G4LogicalVolumeStore::GetInstance();
  auto itr   = store->begin();
  for(; itr != store->end(); itr++)
  {
    G4cout << (*itr)->GetName()
           << "\t Solid = " << (*itr)->GetSolid()->GetName();
    if((*itr)->GetMaterial())
    {
      G4cout << "\t Material = " << (*itr)->GetMaterial()->GetName() << G4endl;
    }
    else
    {
      G4cout << "\t Material : not defined " << G4endl;
    }
    if(lvl < 1)
      continue;
    G4cout << "\t region = ";
    if((*itr)->GetRegion())
    {
      G4cout << (*itr)->GetRegion()->GetName();
    }
    else
    {
      G4cout << "not defined";
    }
    G4cout << "\t sensitive detector = ";
    if((*itr)->GetSensitiveDetector())
    {
      G4cout << (*itr)->GetSensitiveDetector()->GetName();
    }
    else
    {
      G4cout << "not defined";
    }
    G4cout << G4endl;
    G4cout << "\t daughters = " << (*itr)->GetNoDaughters();
    if((*itr)->GetNoDaughters() > 0)
    {
      switch((*itr)->CharacteriseDaughters())
      {
        case kNormal:
          G4cout << " (placement)";
          break;
        case kReplica:
          G4cout << " (replica : " << (*itr)->GetDaughter(0)->GetMultiplicity()
                 << ")";
          break;
        case kParameterised:
          G4cout << " (parameterized : "
                 << (*itr)->GetDaughter(0)->GetMultiplicity() << ")";
          break;
        default:;
      }
    }
    G4cout << G4endl;
    if(lvl < 2)
      continue;
    if((*itr)->GetMaterial())
    {
      G4cout << "\t weight = " << G4BestUnit((*itr)->GetMass(), "Mass")
             << G4endl;
    }
    else
    {
      G4cout << "\t weight : not available" << G4endl;
    }
  }
}

References G4BestUnit, G4cout, G4endl, G4LogicalVolumeStore::GetInstance(), kNormal, kParameterised, and kReplica.

Referenced by DumpVolumes().

◆ DumpPhysVols()

void G4ScoringCylinder::DumpPhysVols ( G4int lvl )

private

Definition at line 826 of file G4ScoringCylinder.cc.

{
  G4cout << "*********** List of registered physical volumes *************"
         << G4endl;
  auto store = G4PhysicalVolumeStore::GetInstance();
  auto itr   = store->begin();
  for(; itr != store->end(); itr++)
  {
    switch(lvl)
    {
      case 0:
        G4cout << (*itr)->GetName() << G4endl;
        break;
      case 1:
        G4cout << (*itr)->GetName() << "\t logical volume = "
               << (*itr)->GetLogicalVolume()->GetName()
               << "\t mother logical = ";
        if((*itr)->GetMotherLogical())
        {
          G4cout << (*itr)->GetMotherLogical()->GetName();
        }
        else
        {
          G4cout << "not defined";
        }
        G4cout << G4endl;
        break;
      default:
        G4cout << (*itr)->GetName() << "\t logical volume = "
               << (*itr)->GetLogicalVolume()->GetName()
               << "\t mother logical = ";
        if((*itr)->GetMotherLogical())
        {
          G4cout << (*itr)->GetMotherLogical()->GetName();
        }
        else
        {
          G4cout << "not defined";
        }
        G4cout << "\t type = ";
        switch((*itr)->VolumeType())
        {
          case kNormal:
            G4cout << "placement";
            break;
          case kReplica:
            G4cout << "replica";
            break;
          case kParameterised:
            G4cout << "parameterized";
            break;
          default:;
        }
        G4cout << G4endl;
    }
  }
}

References G4cout, G4endl, G4PhysicalVolumeStore::GetInstance(), kNormal, kParameterised, and kReplica.

Referenced by DumpVolumes().

◆ DumpSolids()

void G4ScoringCylinder::DumpSolids ( G4int lvl )

private

Definition at line 728 of file G4ScoringCylinder.cc.

{
  G4cout << "*********** List of registered solids *************" << G4endl;
  auto store = G4SolidStore::GetInstance();
  auto itr   = store->begin();
  for(; itr != store->end(); itr++)
  {
    switch(lvl)
    {
      case 0:
        G4cout << (*itr)->GetName() << G4endl;
        break;
      case 1:
        G4cout << (*itr)->GetName() << "\t volume = "
               << G4BestUnit((*itr)->GetCubicVolume(), "Volume")
               << "\t surface = "
               << G4BestUnit((*itr)->GetSurfaceArea(), "Surface") << G4endl;
        break;
      default:
        (*itr)->DumpInfo();
        break;
    }
  }
}

References G4BestUnit, G4cout, G4endl, and G4SolidStore::GetInstance().

Referenced by DumpVolumes().

◆ DumpVolumes()

void G4ScoringCylinder::DumpVolumes ( )

private

Definition at line 720 of file G4ScoringCylinder.cc.

{
  G4int lvl = 2;
  DumpSolids(lvl);
  DumpLogVols(lvl);
  DumpPhysVols(lvl);
}

References DumpLogVols(), DumpPhysVols(), and DumpSolids().

Referenced by SetupGeometry().

◆ 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]; }

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().

◆ 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().

◆ 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().

◆ GetRZPhi()

void G4ScoringCylinder::GetRZPhi	(	G4int	index,
		G4int	q[3]
	)		const

Definition at line 696 of file G4ScoringCylinder.cc.

{
  // index = k + j * k-size + i * jk-plane-size
 
  // nested : z -> phi -> r
  G4int i  = IZ;
  G4int j  = IPHI;
  G4int k  = IR;
  G4int jk = fNSegment[j] * fNSegment[k];
  q[i]     = index / jk;
  q[j]     = (index - q[i] * jk) / fNSegment[k];
  q[k]     = index - q[j] * fNSegment[k] - q[i] * jk;
}

References G4VScoringMesh::fNSegment, IPHI, IR, and IZ.

Referenced by Draw(), and DrawColumn().

◆ 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().

◆ 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 G4ScoringCylinder::List ( ) const

virtual

Reimplemented from G4VScoringMesh.

Definition at line 246 of file G4ScoringCylinder.cc.

{
  G4cout << "G4ScoringCylinder : " << fWorldName
         << " --- Shape: Cylindrical mesh" << G4endl;
 
  G4cout << " Size (Rmin, Rmax, Dz): (" << fSize[0] / cm << ", "
         << fSize[1] / cm << ", " << fSize[2] / cm << ") [cm]" << G4endl;
  G4cout << " Angle (start, span): (" << fAngle[0] / deg << ", "
         << fAngle[1] / deg << ") [deg]" << G4endl;
 
  G4VScoringMesh::List();
}

References cm, deg, G4VScoringMesh::fAngle, 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().

◆ RegisterPrimitives()

void G4ScoringCylinder::RegisterPrimitives ( std::vector< G4VPrimitiveScorer * > & vps )

◆ 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().

◆ SetRMax()

void G4ScoringCylinder::SetRMax ( G4double rMax )

inline

Definition at line 57 of file G4ScoringCylinder.hh.

57{ fSize[1] = rMax; }

References G4VScoringMesh::fSize.

◆ SetRMin()

void G4ScoringCylinder::SetRMin ( G4double rMin )

inline

Definition at line 56 of file G4ScoringCylinder.hh.

56{ fSize[0] = rMin; }

References G4VScoringMesh::fSize.

◆ 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 G4ScoringCylinder::SetupGeometry ( G4VPhysicalVolume * fWorldPhys )

protectedvirtual

Implements G4VScoringMesh.

Definition at line 67 of file G4ScoringCylinder.cc.

{
  if(verboseLevel > 9)
    G4cout << "G4ScoringCylinder::SetupGeometry() ..." << G4endl;
 
  // World
  G4VPhysicalVolume* scoringWorld = fWorldPhys;
  G4LogicalVolume* worldLogical   = scoringWorld->GetLogicalVolume();
 
  // Scoring Mesh
  if(verboseLevel > 9)
    G4cout << fWorldName << G4endl;
  G4String tubsName = fWorldName + "_mesh";
 
  if(verboseLevel > 9)
  {
    G4cout << "R min, R max., Dz =: " << fSize[0] << ", " << fSize[1]
                                      << ", " << fSize[2]  << G4endl;
  }
  G4VSolid* tubsSolid          = new G4Tubs(tubsName + "0",  // name
                                   fSize[0],        // R min
                                   fSize[1],        // R max
                                   fSize[2],        // Dz
                                   fAngle[0],       // starting phi
                                   fAngle[1]);      // segment phi
  G4LogicalVolume* tubsLogical = new G4LogicalVolume(tubsSolid, 0, tubsName);
  new G4PVPlacement(fRotationMatrix, fCenterPosition, tubsLogical,
                    tubsName + "0", worldLogical, false, 0);
 
  if(verboseLevel > 9)
    G4cout << " # of segments : r, phi, z =: " << fNSegment[IR] << ", "
           << fNSegment[IPHI] << ", " << fNSegment[IZ] << G4endl;
 
  G4String layerName[2] = { tubsName + "1", tubsName + "2" };
  G4VSolid* layerSolid[2];
  G4LogicalVolume* layerLogical[2];
 
  //-- fisrt nested layer (replicated along z direction)
  if(verboseLevel > 9)
    G4cout << "layer 1 :" << G4endl;
  layerSolid[0]   = new G4Tubs(layerName[0],              // name
                             fSize[0],                  // inner radius
                             fSize[1],                  // outer radius
                             fSize[2] / fNSegment[IZ],  // half len. in z
                             fAngle[0],                 // starting phi angle
                             fAngle[1]);  // delta angle of the segment
  layerLogical[0] = new G4LogicalVolume(layerSolid[0], 0, layerName[0]);
  if(fNSegment[IZ] > 1)
  {
    if(verboseLevel > 9)
      G4cout << "G4ScoringCylinder::Construct() : Replicate along z direction"
             << G4endl;
    if(G4ScoringManager::GetReplicaLevel() > 0)
    {
      if(verboseLevel > 9)
        G4cout << "G4ScoringCylinder::Construct() : Replica" << G4endl;
      new G4PVReplica(layerName[0], layerLogical[0], tubsLogical, kZAxis,
                      fNSegment[IZ], 2. * fSize[2] / fNSegment[IZ]);
    }
    else
    {
      if(verboseLevel > 9)
        G4cout << "G4ScoringCylinder::Construct() : Division" << G4endl;
      new G4PVDivision(layerName[0], layerLogical[0], tubsLogical, kZAxis,
                       fNSegment[IZ], 0.);
    }
  }
  else if(fNSegment[IZ] == 1)
  {
    if(verboseLevel > 9)
      G4cout << "G4ScoringCylinder::Construct() : Placement" << G4endl;
    new G4PVPlacement(0, G4ThreeVector(0., 0., 0.), layerLogical[0],
                      layerName[0], tubsLogical, false, 0);
  }
  else
  {
    G4cerr << "G4ScoringCylinder::SetupGeometry() : invalid parameter ("
           << fNSegment[IZ] << ") "
           << "in placement of the first nested layer." << G4endl;
  }
 
  // second nested layer (replicated along phi direction)
  if(verboseLevel > 9)
    G4cout << "layer 2 :" << G4endl;
  layerSolid[1] =
    new G4Tubs(layerName[1], fSize[0], fSize[1], fSize[2] / fNSegment[IZ],
               fAngle[0], fAngle[1] / fNSegment[IPHI]);
  layerLogical[1] = new G4LogicalVolume(layerSolid[1], 0, layerName[1]);
  if(fNSegment[IPHI] > 1)
  {
    if(verboseLevel > 9)
      G4cout << "G4ScoringCylinder::Construct() : Replicate along phi direction"
             << G4endl;
    if(G4ScoringManager::GetReplicaLevel() > 1)
    {
      if(verboseLevel > 9)
        G4cout << "G4ScoringCylinder::Construct() : Replica" << G4endl;
      new G4PVReplica(layerName[1], layerLogical[1], layerLogical[0], kPhi,
                      fNSegment[IPHI], fAngle[1] / fNSegment[IPHI], fAngle[0]);
    }
    else
    {
      if(verboseLevel > 9)
        G4cout << "G4ScoringCylinder::Construct() : Division" << G4endl;
      new G4PVDivision(layerName[1], layerLogical[1], layerLogical[0], kPhi,
                       fNSegment[IPHI], 0.);
    }
  }
  else if(fNSegment[IPHI] == 1)
  {
    if(verboseLevel > 9)
      G4cout << "G4ScoringCylinder::Construct() : Placement" << G4endl;
    new G4PVPlacement(0, G4ThreeVector(0., 0., 0.), layerLogical[1],
                      layerName[1], layerLogical[0], false, 0);
  }
  else
    G4cerr << "ERROR : G4ScoringCylinder::SetupGeometry() : invalid parameter ("
           << fNSegment[IPHI] << ") "
           << "in placement of the second nested layer." << G4endl;
 
  // mesh elements
  if(verboseLevel > 9)
    G4cout << "mesh elements :" << G4endl;
  G4String elementName   = tubsName + "3";
  G4VSolid* elementSolid = new G4Tubs(
    elementName, fSize[0], (fSize[1] - fSize[0]) / fNSegment[IR] + fSize[0],
    fSize[2] / fNSegment[IZ], fAngle[0], fAngle[1] / fNSegment[IPHI]);
  fMeshElementLogical = new G4LogicalVolume(elementSolid, 0, elementName);
  if(fNSegment[IR] >= 1)
  {
    if(verboseLevel > 9)
      G4cout << "G4ScoringCylinder::Construct() : Replicate along r direction"
             << G4endl;
 
    if(G4ScoringManager::GetReplicaLevel() > 2)
    {
      if(verboseLevel > 9)
        G4cout << "G4ScoringCylinder::Construct() : Replica" << G4endl;
      new G4PVReplica(elementName, fMeshElementLogical, layerLogical[1], kRho,
                      fNSegment[IR], (fSize[1] - fSize[0]) / fNSegment[IR],
                      fSize[0]);
    }
    else
    {
      if(verboseLevel > 9)
        G4cout << "G4ScoringCylinder::Construct() : Division" << G4endl;
      new G4PVDivision(elementName, fMeshElementLogical, layerLogical[1], kRho,
                       fNSegment[IR], 0.);
    }
    //  } else if(fNSegment[IR] == 1) {
    //    if(verboseLevel > 9) G4cout << "G4ScoringCylinder::Construct() :
    //    Placement" << G4endl;
    // G4cout<<"#@#@#@#@#@ G4ScoringCylinder::Construct() : Placement "<<G4endl;
    //    new G4PVPlacement(0, G4ThreeVector(0.,0.,0.), fMeshElementLogical,
    //    elementName, layerLogical[1], false, 0);
  }
  else
  {
    G4cerr << "G4ScoringCylinder::SetupGeometry() : "
           << "invalid parameter (" << fNSegment[IR] << ") "
           << "in mesh element placement." << G4endl;
  }
 
  // set the sensitive detector
  fMeshElementLogical->SetSensitiveDetector(fMFD);
 
  // vis. attributes
  G4VisAttributes* visatt = new G4VisAttributes(G4Colour(.5, .5, .5));
  visatt->SetVisibility(true);
  layerLogical[0]->SetVisAttributes(visatt);
  layerLogical[1]->SetVisAttributes(visatt);
  visatt = new G4VisAttributes(G4Colour(.5, .5, .5, 0.01));
  // visatt->SetForceSolid(true);
  fMeshElementLogical->SetVisAttributes(visatt);
 
  if(verboseLevel > 9)
    DumpVolumes();
}

References DumpVolumes(), G4VScoringMesh::fAngle, G4VScoringMesh::fCenterPosition, G4VScoringMesh::fMeshElementLogical, G4VScoringMesh::fMFD, G4VScoringMesh::fNSegment, G4VScoringMesh::fRotationMatrix, G4VScoringMesh::fSize, G4VScoringMesh::fWorldName, G4cerr, G4cout, G4endl, G4VPhysicalVolume::GetLogicalVolume(), G4ScoringManager::GetReplicaLevel(), IPHI, IR, IZ, kPhi, kRho, 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().

◆ SetZSize()

void G4ScoringCylinder::SetZSize ( G4double zSize )

inline

Definition at line 58 of file G4ScoringCylinder.hh.

58{ fSize[2] = zSize; } // half height

References G4VScoringMesh::fSize.

◆ 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 Draw(), DrawColumn(), G4VScoringMesh::G4VScoringMesh(), G4VScoringMesh::GetAngleSpan(), G4VScoringMesh::GetStartAngle(), List(), G4VScoringMesh::SetAngles(), and SetupGeometry().

◆ fCenterPosition

G4ThreeVector G4VScoringMesh::fCenterPosition

protectedinherited

Definition at line 207 of file G4VScoringMesh.hh.

Referenced by G4ScoringBox::Draw(), Draw(), G4ScoringBox::DrawColumn(), DrawColumn(), G4VScoringMesh::GetTranslation(), G4VScoringMesh::List(), G4VScoringMesh::SetCenterPosition(), G4ScoringBox::SetupGeometry(), and 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::G4ScoringBox(), G4ScoringCylinder(), G4VScoringMesh::G4VScoringMesh(), and G4VScoringMesh::GetDivisionAxisNames().

◆ fDrawPSName

G4String G4VScoringMesh::fDrawPSName

protectedinherited

Definition at line 221 of file G4VScoringMesh.hh.

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

◆ fDrawUnit

G4String G4VScoringMesh::fDrawUnit

protectedinherited

Definition at line 219 of file G4VScoringMesh.hh.

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

◆ fDrawUnitValue

G4double G4VScoringMesh::fDrawUnitValue

protectedinherited

Definition at line 220 of file G4VScoringMesh.hh.

Referenced by G4ScoringBox::Draw(), Draw(), G4ScoringBox::DrawColumn(), 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(), G4ScoringBox::SetupGeometry(), 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(), G4ScoringBox::SetupGeometry(), SetupGeometry(), and G4VScoringMesh::WorkerConstruct().

◆ fNSegment

G4int G4VScoringMesh::fNSegment[3]

protectedinherited

Definition at line 209 of file G4VScoringMesh.hh.

Referenced by G4ScoringBox::Draw(), Draw(), G4ScoringBox::DrawColumn(), DrawColumn(), G4VScoringMesh::G4VScoringMesh(), G4ScoringBox::GetIndex(), G4VScoringMesh::GetNumberOfSegments(), G4ScoringBox::GetReplicaPosition(), GetRZPhi(), G4ScoringBox::GetXYZ(), G4VScoringMesh::List(), G4VScoringMesh::SetNumberOfSegments(), G4VScoringMesh::SetPrimitiveScorer(), G4ScoringBox::SetupGeometry(), and 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 G4ScoringBox::Draw(), Draw(), G4ScoringBox::DrawColumn(), DrawColumn(), G4VScoringMesh::GetRotationMatrix(), G4VScoringMesh::List(), G4VScoringMesh::RotateX(), G4VScoringMesh::RotateY(), G4VScoringMesh::RotateZ(), G4ScoringBox::SetupGeometry(), and SetupGeometry().

◆ fShape

MeshShape G4VScoringMesh::fShape

protectedinherited

Definition at line 203 of file G4VScoringMesh.hh.

Referenced by G4ScoringBox::G4ScoringBox(), 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 G4ScoringBox::Draw(), Draw(), G4ScoringBox::DrawColumn(), DrawColumn(), G4VScoringMesh::G4VScoringMesh(), G4ScoringBox::GetReplicaPosition(), G4VScoringMesh::GetSize(), G4ScoringBox::List(), List(), SetRMax(), SetRMin(), G4VScoringMesh::SetSize(), G4ScoringBox::SetupGeometry(), SetupGeometry(), and SetZSize().

◆ fWorldName

G4String G4VScoringMesh::fWorldName

protectedinherited

Definition at line 199 of file G4VScoringMesh.hh.

Referenced by G4VScoringMesh::Construct(), G4VScoringMesh::Dump(), G4VScoringMesh::GetWorldName(), G4ScoringBox::List(), List(), G4VScoringMesh::SetPrimitiveScorer(), G4ScoringBox::SetupGeometry(), and 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(), G4ScoringBox::SetupGeometry(), SetupGeometry(), G4VScoringMesh::SetVerboseLevel(), and G4VScoringMesh::WorkerConstruct().

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

source/digits_hits/utils/include/G4ScoringCylinder.hh
source/digits_hits/utils/src/G4ScoringCylinder.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

Detailed Description

Member Typedef Documentation

◆ EventScore

◆ MeshScoreMap

◆ RunScore

Member Enumeration Documentation

◆ IDX

◆ MeshShape

Constructor & Destructor Documentation

◆ G4ScoringCylinder()

◆ ~G4ScoringCylinder()

Member Function Documentation

◆ Accumulate() [1/2]

◆ Accumulate() [2/2]

◆ Activate()

◆ Construct()

◆ Draw()

◆ DrawColumn()

◆ DrawMesh() [1/2]

◆ DrawMesh() [2/2]

◆ Dump()

◆ DumpLogVols()

◆ DumpPhysVols()

◆ DumpSolids()

◆ DumpVolumes()

◆ FindPrimitiveScorer()

◆ GeometryHasBeenDestroyed()

◆ GetAngleSpan()

◆ GetCopyNumberLevel()

◆ GetCurrentPSUnit()

◆ GetDivisionAxisNames()

◆ GetMeshElementLogical()

◆ GetNumberOfSegments()

◆ GetParallelWorldProcess()

◆ GetPrimitiveScorer()

◆ GetPSUnit()

◆ GetPSUnitValue()

◆ GetRotationMatrix()

◆ GetRZPhi()

◆ GetScoreMap()

◆ GetShape()

◆ GetSize()

◆ GetStartAngle()

◆ GetTranslation()

◆ GetWorldName()

◆ IsActive()

◆ IsCurrentPrimitiveScorerNull()

◆ LayeredMassFlg()

◆ List()

◆ Merge()

◆ ReadyForQuantity()

◆ RegisterPrimitives()

◆ ResetScore()

◆ RotateX()

◆ RotateY()

◆ RotateZ()

◆ SetAngles()

◆ SetCenterPosition()

◆ SetCopyNumberLevel()

◆ SetCurrentPrimitiveScorer()

◆ SetCurrentPSUnit()

◆ SetDrawPSName()

◆ SetFilter()

◆ SetMeshElementLogical()

◆ SetNullToCurrentPrimitiveScorer()

◆ SetNumberOfSegments()

◆ SetParallelWorldProcess()

◆ SetPrimitiveScorer()

◆ SetRMax()

◆ SetRMin()

◆ SetSize()

◆ SetupGeometry()

◆ SetVerboseLevel()

◆ SetZSize()

◆ WorkerConstruct()