Geant4 11.2.2
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Public Member Functions | Protected Member Functions | List of all members
G4ScoringCylinder Class Reference

#include <G4ScoringCylinder.hh>

+ Inheritance diagram for G4ScoringCylinder:

Public Member Functions

 G4ScoringCylinder (G4String wName)
 
 ~G4ScoringCylinder () override=default
 
void List () const override
 
void Draw (RunScore *map, G4VScoreColorMap *colorMap, G4int axflg=111) override
 
void DrawColumn (RunScore *map, G4VScoreColorMap *colorMap, G4int idxProj, G4int idxColumn) override
 
void SetRMin (G4double rMin)
 
void SetRMax (G4double rMax)
 
void SetZSize (G4double zSize)
 
void RegisterPrimitives (std::vector< G4VPrimitiveScorer * > &vps)
 
void GetRZPhi (G4int index, G4int q[3]) const
 
- Public Member Functions inherited from G4VScoringMesh
 G4VScoringMesh (const G4String &wName)
 
virtual ~G4VScoringMesh ()=default
 
virtual void Construct (G4VPhysicalVolume *fWorldPhys)
 
virtual void WorkerConstruct (G4VPhysicalVolume *fWorldPhys)
 
const G4String & GetWorldName () const
 
G4bool IsActive () const
 
void Activate (G4bool vl=true)
 
MeshShape GetShape () const
 
void Accumulate (G4THitsMap< G4double > *map)
 
void Accumulate (G4THitsMap< G4StatDouble > *map)
 
void Merge (const G4VScoringMesh *scMesh)
 
void Dump ()
 
void DrawMesh (const G4String &psName, G4VScoreColorMap *colorMap, G4int axflg=111)
 
void DrawMesh (const G4String &psName, G4int idxPlane, G4int iColumn, G4VScoreColorMap *colorMap)
 
void ResetScore ()
 
void SetSize (G4double size[3])
 
G4ThreeVector GetSize () const
 
void SetAngles (G4double, G4double)
 
G4double GetStartAngle () const
 
G4double GetAngleSpan () const
 
void SetCenterPosition (G4double centerPosition[3])
 
G4ThreeVector GetTranslation () const
 
void RotateX (G4double delta)
 
void RotateY (G4double delta)
 
void RotateZ (G4double delta)
 
G4RotationMatrix GetRotationMatrix () const
 
void SetNumberOfSegments (G4int nSegment[3])
 
void GetNumberOfSegments (G4int nSegment[3])
 
void SetPrimitiveScorer (G4VPrimitiveScorer *ps)
 
void SetFilter (G4VSDFilter *filter)
 
void SetCurrentPrimitiveScorer (const G4String &name)
 
G4bool FindPrimitiveScorer (const G4String &psname)
 
G4bool IsCurrentPrimitiveScorerNull ()
 
G4String GetPSUnit (const G4String &psname)
 
G4String GetCurrentPSUnit ()
 
void SetCurrentPSUnit (const G4String &unit)
 
G4double GetPSUnitValue (const G4String &psname)
 
void SetDrawPSName (const G4String &psname)
 
void GetDivisionAxisNames (G4String divisionAxisNames[3])
 
void SetNullToCurrentPrimitiveScorer ()
 
void SetVerboseLevel (G4int vl)
 
MeshScoreMap GetScoreMap () const
 
G4bool ReadyForQuantity () const
 
G4VPrimitiveScorer * GetPrimitiveScorer (const G4String &name)
 
void SetMeshElementLogical (G4LogicalVolume *val)
 
G4LogicalVolume * GetMeshElementLogical () const
 
void SetParallelWorldProcess (G4ParallelWorldProcess *proc)
 
G4ParallelWorldProcess * GetParallelWorldProcess () const
 
void GeometryHasBeenDestroyed ()
 
void SetCopyNumberLevel (G4int val)
 
G4int GetCopyNumberLevel () const
 
G4bool LayeredMassFlg ()
 

Protected Member Functions

void SetupGeometry (G4VPhysicalVolume *fWorldPhys) override
 
- Protected Member Functions inherited from G4VScoringMesh

Additional Inherited Members

- Public Types inherited from G4VScoringMesh
enum class  MeshShape {
  box , cylinder , sphere , realWorldLogVol ,
  probe , undefined = -1
}
 
using EventScore = G4THitsMap<G4double>
 
using RunScore = G4THitsMap<G4StatDouble>
 
using MeshScoreMap = std::map<G4String, RunScore*>
 
- Protected Attributes inherited from G4VScoringMesh
G4String fWorldName
 
G4VPrimitiveScorer * fCurrentPS
 
G4bool fConstructed
 
G4bool fActive
 
MeshShape fShape
 
G4double fSize [3]
 
G4double fAngle [2]
 
G4ThreeVector fCenterPosition
 
G4RotationMatrix * fRotationMatrix
 
G4int fNSegment [3]
 
MeshScoreMap fMap
 
G4MultiFunctionalDetector * fMFD
 
G4int verboseLevel
 
G4bool sizeIsSet
 
G4bool nMeshIsSet
 
G4String fDrawUnit
 
G4double fDrawUnitValue
 
G4String fDrawPSName
 
G4String fDivisionAxisNames [3]
 
G4LogicalVolume * fMeshElementLogical
 
G4ParallelWorldProcess * fParallelWorldProcess
 
G4bool fGeometryHasBeenDestroyed
 
G4int copyNumberLevel
 
G4bool layeredMassFlg
 

Detailed Description

Definition at line 40 of file G4ScoringCylinder.hh.

Constructor & Destructor Documentation

◆ G4ScoringCylinder()

G4ScoringCylinder::G4ScoringCylinder ( G4String wName)

Definition at line 48 of file G4ScoringCylinder.cc.

49 : G4VScoringMesh(wName)
50{
51 fShape = MeshShape::cylinder;
52
53 fDivisionAxisNames[0] = "Z";
54 fDivisionAxisNames[1] = "PHI";
55 fDivisionAxisNames[2] = "R";
56}
G4VScoringMesh::fDivisionAxisNames
G4String fDivisionAxisNames[3]
Definition G4VScoringMesh.hh:247
G4VScoringMesh::G4VScoringMesh
G4VScoringMesh(const G4String &wName)
Definition G4VScoringMesh.cc:45

◆ ~G4ScoringCylinder()

G4ScoringCylinder::~G4ScoringCylinder ( )
overridedefault

Member Function Documentation

◆ Draw()

void G4ScoringCylinder::Draw ( RunScore * map,
G4VScoreColorMap * colorMap,
G4int axflg = 111 )
overridevirtual

Implements G4VScoringMesh.

Definition at line 244 of file G4ScoringCylinder.cc.

246{
247 G4VVisManager* pVisManager = G4VVisManager::GetConcreteInstance();
248 if(pVisManager != nullptr)
249 {
250 // cell vectors
251 std::vector<double> ephi;
252 for(int phi = 0; phi < fNSegment[IPHI]; phi++)
253 ephi.push_back(0.);
254 //-
255 std::vector<std::vector<double>> zphicell; // zphicell[Z][PHI]
256 for(int z = 0; z < fNSegment[IZ]; z++)
257 zphicell.push_back(ephi);
258 //-
259 std::vector<std::vector<double>> rphicell; // rphicell[R][PHI]
260 for(int r = 0; r < fNSegment[IR]; r++)
261 rphicell.push_back(ephi);
262
263 // projections
264 G4int q[3];
265 auto itr = map->GetMap()->begin();
266 for(; itr != map->GetMap()->end(); itr++)
267 {
268 if(itr->first < 0)
269 {
270 G4cout << itr->first << G4endl;
271 continue;
272 }
273 GetRZPhi(itr->first, q);
274
275 zphicell[q[IZ]][q[IPHI]] += (itr->second->sum_wx()) / fDrawUnitValue;
276 rphicell[q[IR]][q[IPHI]] += (itr->second->sum_wx()) / fDrawUnitValue;
277 }
278
279 // search min./max. values
280 G4double zphimin = DBL_MAX, rphimin = DBL_MAX;
281 G4double zphimax = 0., rphimax = 0.;
282 for(int iphi = 0; iphi < fNSegment[IPHI]; iphi++)
283 {
284 for(int iz = 0; iz < fNSegment[IZ]; iz++)
285 {
286 if(zphimin > zphicell[iz][iphi])
287 zphimin = zphicell[iz][iphi];
288 if(zphimax < zphicell[iz][iphi])
289 zphimax = zphicell[iz][iphi];
290 }
291 for(int ir = 0; ir < fNSegment[IR]; ir++)
292 {
293 if(rphimin > rphicell[ir][iphi])
294 rphimin = rphicell[ir][iphi];
295 if(rphimax < rphicell[ir][iphi])
296 rphimax = rphicell[ir][iphi];
297 }
298 }
299
300 G4VisAttributes att;
301 att.SetForceSolid(true);
302 att.SetForceAuxEdgeVisible(true);
303
304 G4Scale3D scale;
305 if(axflg / 100 == 1)
306 {
307 // rz plane
308 }
309 axflg = axflg % 100;
310 if(axflg / 10 == 1)
311 {
312 pVisManager->BeginDraw();
313
314 // z-phi plane
315 if(colorMap->IfFloatMinMax())
316 {
317 colorMap->SetMinMax(zphimin, zphimax);
318 }
319
320 G4double zhalf = fSize[2] / fNSegment[IZ];
321 for(int phi = 0; phi < fNSegment[IPHI]; phi++)
322 {
323 for(int z = 0; z < fNSegment[IZ]; z++)
324 {
325 //-
326 G4double angle = fAngle[0] + fAngle[1] / fNSegment[IPHI] * phi;
327 G4double dphi = fAngle[1] / fNSegment[IPHI];
328 G4Tubs cylinder(
329 "z-phi", // name
330 fSize[1] * 0.99, fSize[1], // inner radius, outer radius
331 zhalf, // half length in z
332 angle, dphi * 0.99999); // starting phi angle, delta angle
333 //-
334 G4ThreeVector zpos(
335 0., 0., -fSize[2] + fSize[2] / fNSegment[IZ] * (1 + 2. * z));
336 G4Transform3D trans;
337 if(fRotationMatrix != nullptr)
338 {
339 trans =
340 G4Rotate3D(*fRotationMatrix).inverse() * G4Translate3D(zpos);
341 trans = G4Translate3D(fCenterPosition) * trans;
342 }
343 else
344 {
345 trans = G4Translate3D(zpos) * G4Translate3D(fCenterPosition);
346 }
347 G4double c[4];
348 colorMap->GetMapColor(zphicell[z][phi], c);
349 att.SetColour(c[0], c[1], c[2]); //, c[3]);
350 //-
351 G4Polyhedron* poly = cylinder.GetPolyhedron();
352 poly->Transform(trans);
353 poly->SetVisAttributes(att);
354 pVisManager->Draw(*poly);
355 }
356 }
357 pVisManager->EndDraw();
358 }
359 axflg = axflg % 10;
360 if(axflg == 1)
361 {
362 pVisManager->BeginDraw();
363
364 // r-phi plane
365 if(colorMap->IfFloatMinMax())
366 {
367 colorMap->SetMinMax(rphimin, rphimax);
368 }
369
370 G4double rsize = (fSize[1] - fSize[0]) / fNSegment[IR];
371 for(int phi = 0; phi < fNSegment[IPHI]; phi++)
372 {
373 for(int r = 0; r < fNSegment[IR]; r++)
374 {
375 G4double rs[2] = { fSize[0] + rsize * r, fSize[0] + rsize * (r + 1) };
376 G4double angle = fAngle[0] + fAngle[1] / fNSegment[IPHI] * phi;
377 G4double dphi = fAngle[1] / fNSegment[IPHI];
378 G4Tubs cylindern("z-phi", rs[0], rs[1], 0.001, angle, dphi * 0.99999);
379 G4Tubs cylinderp = cylindern;
380
381 G4ThreeVector zposn(0., 0., -fSize[2]);
382 G4ThreeVector zposp(0., 0., fSize[2]);
383 G4Transform3D transn, transp;
384 if(fRotationMatrix != nullptr)
385 {
386 transn =
387 G4Rotate3D(*fRotationMatrix).inverse() * G4Translate3D(zposn);
388 transn = G4Translate3D(fCenterPosition) * transn;
389 transp =
390 G4Rotate3D(*fRotationMatrix).inverse() * G4Translate3D(zposp);
391 transp = G4Translate3D(fCenterPosition) * transp;
392 }
393 else
394 {
395 transn = G4Translate3D(zposn) * G4Translate3D(fCenterPosition);
396 transp = G4Translate3D(zposp) * G4Translate3D(fCenterPosition);
397 }
398 G4double c[4];
399 colorMap->GetMapColor(rphicell[r][phi], c);
400 att.SetColour(c[0], c[1], c[2]); //, c[3]);
401
402 G4Polyhedron* polyn = cylindern.GetPolyhedron();
403 polyn->Transform(transn);
404 polyn->SetVisAttributes(att);
405 pVisManager->Draw(*polyn);
406
407 G4Polyhedron* polyp = cylinderp.GetPolyhedron();
408 polyp->Transform(transp);
409 polyp->SetVisAttributes(att);
410 pVisManager->Draw(*polyp);
411 }
412 }
413
414 pVisManager->EndDraw();
415 }
416
417 colorMap->SetPSUnit(fDrawUnit);
418 colorMap->SetPSName(fDrawPSName);
419 colorMap->DrawColorChart();
420 }
421}
G4Translate3D
HepGeom::Translate3D G4Translate3D
Definition G4Transform3D.hh:40
G4Rotate3D
HepGeom::Rotate3D G4Rotate3D
Definition G4Transform3D.hh:35
G4double
double G4double
Definition G4Types.hh:83
G4int
int G4int
Definition G4Types.hh:85
G4endl
#define G4endl
Definition G4ios.hh:67
G4cout
G4GLOB_DLL std::ostream G4cout
G4CSGSolid::GetPolyhedron
G4Polyhedron * GetPolyhedron() const override
Definition G4CSGSolid.cc:129
G4ScoringCylinder::GetRZPhi
void GetRZPhi(G4int index, G4int q[3]) const
Definition G4ScoringCylinder.cc:681
G4VScoreColorMap::DrawColorChart
virtual void DrawColorChart(G4int nPoint=5)
Definition G4VScoreColorMap.cc:46
G4VScoreColorMap::IfFloatMinMax
G4bool IfFloatMinMax() const
Definition G4VScoreColorMap.hh:48
G4VScoreColorMap::SetMinMax
void SetMinMax(G4double minVal, G4double maxVal)
Definition G4VScoreColorMap.hh:49
G4VScoreColorMap::SetPSUnit
void SetPSUnit(G4String &unit)
Definition G4VScoreColorMap.hh:75
G4VScoreColorMap::GetMapColor
virtual void GetMapColor(G4double val, G4double color[4])=0
G4VScoreColorMap::SetPSName
void SetPSName(G4String &psName)
Definition G4VScoreColorMap.hh:76
G4VScoringMesh::fRotationMatrix
G4RotationMatrix * fRotationMatrix
Definition G4VScoringMesh.hh:232
G4VScoringMesh::fDrawUnitValue
G4double fDrawUnitValue
Definition G4VScoringMesh.hh:244
G4VScoringMesh::fAngle
G4double fAngle[2]
Definition G4VScoringMesh.hh:230
G4VScoringMesh::fSize
G4double fSize[3]
Definition G4VScoringMesh.hh:229
G4VScoringMesh::fCenterPosition
G4ThreeVector fCenterPosition
Definition G4VScoringMesh.hh:231
G4VVisManager::EndDraw
virtual void EndDraw()=0
G4VVisManager::GetConcreteInstance
static G4VVisManager * GetConcreteInstance()
Definition G4VVisManager.cc:41
G4VVisManager::Draw
virtual void Draw(const G4Circle &, const G4Transform3D &objectTransformation=G4Transform3D())=0
G4VVisManager::BeginDraw
virtual void BeginDraw(const G4Transform3D &objectTransformation=G4Transform3D())=0
G4VisAttributes::SetColour
void SetColour(const G4Colour &)
G4VisAttributes::SetForceAuxEdgeVisible
void SetForceAuxEdgeVisible(G4bool=true)
Definition G4VisAttributes.cc:179
G4VisAttributes::SetForceSolid
void SetForceSolid(G4bool=true)
Definition G4VisAttributes.cc:149
G4Visible::SetVisAttributes
void SetVisAttributes(const G4VisAttributes *)
Definition G4Visible.cc:98
HepGeom::Transform3D::inverse
Transform3D inverse() const
Definition Transform3D.cc:141
HepPolyhedron::Transform
HepPolyhedron & Transform(const G4Transform3D &t)
Definition HepPolyhedron.cc:1379
DBL_MAX
#define DBL_MAX
Definition templates.hh:62

◆ DrawColumn()

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

Implements G4VScoringMesh.

Definition at line 423 of file G4ScoringCylinder.cc.

425{
426 G4int projAxis = 0;
427 switch(idxProj)
428 {
429 case 0:
430 projAxis = IR;
431 break;
432 case 1:
433 projAxis = IZ;
434 break;
435 case 2:
436 projAxis = IPHI;
437 break;
438 }
439
440 if(idxColumn < 0 || idxColumn >= fNSegment[projAxis])
441 {
442 G4cerr << "Warning : Column number " << idxColumn
443 << " is out of scoring mesh [0," << fNSegment[projAxis] - 1
444 << "]. Method ignored." << G4endl;
445 return;
446 }
447 G4VVisManager* pVisManager = G4VVisManager::GetConcreteInstance();
448 if(pVisManager != nullptr)
449 {
450 // cell vectors
451 std::vector<std::vector<std::vector<double>>> cell; // cell[R][Z][PHI]
452 std::vector<double> ephi;
453 for(int phi = 0; phi < fNSegment[IPHI]; phi++)
454 ephi.push_back(0.);
455 std::vector<std::vector<double>> ezphi;
456 for(int z = 0; z < fNSegment[IZ]; z++)
457 ezphi.push_back(ephi);
458 for(int r = 0; r < fNSegment[IR]; r++)
459 cell.push_back(ezphi);
460
461 std::vector<std::vector<double>> rzcell; // rzcell[R][Z]
462 std::vector<double> ez;
463 for(int z = 0; z < fNSegment[IZ]; z++)
464 ez.push_back(0.);
465 for(int r = 0; r < fNSegment[IR]; r++)
466 rzcell.push_back(ez);
467
468 std::vector<std::vector<double>> zphicell; // zphicell[Z][PHI]
469 for(int z = 0; z < fNSegment[IZ]; z++)
470 zphicell.push_back(ephi);
471
472 std::vector<std::vector<double>> rphicell; // rphicell[R][PHI]
473 for(int r = 0; r < fNSegment[IR]; r++)
474 rphicell.push_back(ephi);
475
476 // projections
477 G4int q[3];
478 auto itr = map->GetMap()->begin();
479 for(; itr != map->GetMap()->end(); itr++)
480 {
481 if(itr->first < 0)
482 {
483 G4cout << itr->first << G4endl;
484 continue;
485 }
486 GetRZPhi(itr->first, q);
487
488 if(projAxis == IR && q[IR] == idxColumn)
489 { // zphi plane
490 zphicell[q[IZ]][q[IPHI]] += (itr->second->sum_wx()) / fDrawUnitValue;
491 }
492 if(projAxis == IZ && q[IZ] == idxColumn)
493 { // rphi plane
494 rphicell[q[IR]][q[IPHI]] += (itr->second->sum_wx()) / fDrawUnitValue;
495 }
496 if(projAxis == IPHI && q[IPHI] == idxColumn)
497 { // rz plane
498 rzcell[q[IR]][q[IZ]] += (itr->second->sum_wx()) / fDrawUnitValue;
499 }
500 }
501
502 // search min./max. values
503 G4double rzmin = DBL_MAX, zphimin = DBL_MAX, rphimin = DBL_MAX;
504 G4double rzmax = 0., zphimax = 0., rphimax = 0.;
505 for(int r = 0; r < fNSegment[IR]; r++)
506 {
507 for(int phi = 0; phi < fNSegment[IPHI]; phi++)
508 {
509 if(rphimin > rphicell[r][phi])
510 rphimin = rphicell[r][phi];
511 if(rphimax < rphicell[r][phi])
512 rphimax = rphicell[r][phi];
513 }
514 for(int z = 0; z < fNSegment[IZ]; z++)
515 {
516 if(rzmin > rzcell[r][z])
517 rzmin = rzcell[r][z];
518 if(rzmax < rzcell[r][z])
519 rzmax = rzcell[r][z];
520 }
521 }
522 for(int z = 0; z < fNSegment[IZ]; z++)
523 {
524 for(int phi = 0; phi < fNSegment[IPHI]; phi++)
525 {
526 if(zphimin > zphicell[z][phi])
527 zphimin = zphicell[z][phi];
528 if(zphimax < zphicell[z][phi])
529 zphimax = zphicell[z][phi];
530 }
531 }
532
533 G4VisAttributes att;
534 att.SetForceSolid(true);
535 att.SetForceAuxEdgeVisible(true);
536
537 pVisManager->BeginDraw();
538
539 G4Scale3D scale;
540 // z-phi plane
541 if(projAxis == IR)
542 {
543 if(colorMap->IfFloatMinMax())
544 {
545 colorMap->SetMinMax(zphimin, zphimax);
546 }
547
548 G4double zhalf = fSize[2] / fNSegment[IZ];
549 G4double rsize[2] = {
550 fSize[0] + (fSize[1] - fSize[0]) / fNSegment[IR] * idxColumn,
551 fSize[0] + (fSize[1] - fSize[0]) / fNSegment[IR] * (idxColumn + 1)
552 };
553 for(int phi = 0; phi < fNSegment[IPHI]; phi++)
554 {
555 for(int z = 0; z < fNSegment[IZ]; z++)
556 {
557 G4double angle = fAngle[0] + fAngle[1] / fNSegment[IPHI] * phi;
558 G4double dphi = fAngle[1] / fNSegment[IPHI];
559 G4Tubs cylinder("z-phi", rsize[0], rsize[1], zhalf, angle,
560 dphi * 0.99999);
561
562 G4ThreeVector zpos(
563 0., 0., -fSize[2] + fSize[2] / fNSegment[IZ] * (1 + 2. * z));
564 G4Transform3D trans;
565 if(fRotationMatrix != nullptr)
566 {
567 trans =
568 G4Rotate3D(*fRotationMatrix).inverse() * G4Translate3D(zpos);
569 trans = G4Translate3D(fCenterPosition) * trans;
570 }
571 else
572 {
573 trans = G4Translate3D(zpos) * G4Translate3D(fCenterPosition);
574 }
575 G4double c[4];
576 colorMap->GetMapColor(zphicell[z][phi], c);
577 att.SetColour(c[0], c[1], c[2]); //, c[3]);
578
579 G4Polyhedron* poly = cylinder.GetPolyhedron();
580 poly->Transform(trans);
581 poly->SetVisAttributes(att);
582 pVisManager->Draw(*poly);
583 }
584 }
585
586 // r-phi plane
587 }
588 else if(projAxis == IZ)
589 {
590 if(colorMap->IfFloatMinMax())
591 {
592 colorMap->SetMinMax(rphimin, rphimax);
593 }
594
595 G4double rsize = (fSize[1] - fSize[0]) / fNSegment[IR];
596 for(int phi = 0; phi < fNSegment[IPHI]; phi++)
597 {
598 for(int r = 0; r < fNSegment[IR]; r++)
599 {
600 G4double rs[2] = { fSize[0] + rsize * r, fSize[0] + rsize * (r + 1) };
601 G4double angle = fAngle[0] + fAngle[1] / fNSegment[IPHI] * phi;
602 G4double dz = fSize[2] / fNSegment[IZ];
603 G4double dphi = fAngle[1] / fNSegment[IPHI];
604 G4Tubs cylinder("r-phi", rs[0], rs[1], dz, angle, dphi * 0.99999);
605 G4ThreeVector zpos(
606 0., 0., -fSize[2] + fSize[2] / fNSegment[IZ] * (idxColumn * 2 + 1));
607 G4Transform3D trans;
608 if(fRotationMatrix != nullptr)
609 {
610 trans =
611 G4Rotate3D(*fRotationMatrix).inverse() * G4Translate3D(zpos);
612 trans = G4Translate3D(fCenterPosition) * trans;
613 }
614 else
615 {
616 trans = G4Translate3D(zpos) * G4Translate3D(fCenterPosition);
617 }
618 G4double c[4];
619 colorMap->GetMapColor(rphicell[r][phi], c);
620 att.SetColour(c[0], c[1], c[2]); //, c[3]);
621
622 G4Polyhedron* poly = cylinder.GetPolyhedron();
623 poly->Transform(trans);
624 poly->SetVisAttributes(att);
625 pVisManager->Draw(*poly);
626 }
627 }
628
629 // r-z plane
630 }
631 else if(projAxis == IPHI)
632 {
633 if(colorMap->IfFloatMinMax())
634 {
635 colorMap->SetMinMax(rzmin, rzmax);
636 }
637
638 G4double rsize = (fSize[1] - fSize[0]) / fNSegment[IR];
639 G4double zhalf = fSize[2] / fNSegment[IZ];
640 G4double angle = fAngle[0] + fAngle[1] / fNSegment[IPHI] * idxColumn;
641 G4double dphi = fAngle[1] / fNSegment[IPHI];
642 for(int z = 0; z < fNSegment[IZ]; z++)
643 {
644 for(int r = 0; r < fNSegment[IR]; r++)
645 {
646 G4double rs[2] = { fSize[0] + rsize * r, fSize[0] + rsize * (r + 1) };
647 G4Tubs cylinder("z-phi", rs[0], rs[1], zhalf, angle, dphi);
648
649 G4ThreeVector zpos(
650 0., 0., -fSize[2] + fSize[2] / fNSegment[IZ] * (2. * z + 1));
651 G4Transform3D trans;
652 if(fRotationMatrix != nullptr)
653 {
654 trans =
655 G4Rotate3D(*fRotationMatrix).inverse() * G4Translate3D(zpos);
656 trans = G4Translate3D(fCenterPosition) * trans;
657 }
658 else
659 {
660 trans = G4Translate3D(zpos) * G4Translate3D(fCenterPosition);
661 }
662 G4double c[4];
663 colorMap->GetMapColor(rzcell[r][z], c);
664 att.SetColour(c[0], c[1], c[2]); //, c[3]);
665
666 G4Polyhedron* poly = cylinder.GetPolyhedron();
667 poly->Transform(trans);
668 poly->SetVisAttributes(att);
669 pVisManager->Draw(*poly);
670 }
671 }
672 }
673 pVisManager->EndDraw();
674 }
675
676 colorMap->SetPSUnit(fDrawUnit);
677 colorMap->SetPSName(fDrawPSName);
678 colorMap->DrawColorChart();
679}
G4cerr
G4GLOB_DLL std::ostream G4cerr

◆ GetRZPhi()

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

Definition at line 681 of file G4ScoringCylinder.cc.

682{
683 // index = k + j * k-size + i * jk-plane-size
684
685 // nested : z -> phi -> r
686 G4int i = IZ;
687 G4int j = IPHI;
688 G4int k = IR;
689 G4int jk = fNSegment[j] * fNSegment[k];
690 q[i] = index / jk;
691 q[j] = (index - q[i] * jk) / fNSegment[k];
692 q[k] = index - q[j] * fNSegment[k] - q[i] * jk;
693}

Referenced by Draw(), and DrawColumn().

◆ List()

void G4ScoringCylinder::List ( ) const
overridevirtual

Reimplemented from G4VScoringMesh.

Definition at line 231 of file G4ScoringCylinder.cc.

232{
233 G4cout << "G4ScoringCylinder : " << fWorldName
234 << " --- Shape: Cylindrical mesh" << G4endl;
235
236 G4cout << " Size (Rmin, Rmax, Dz): (" << fSize[0] / cm << ", "
237 << fSize[1] / cm << ", " << fSize[2] / cm << ") [cm]" << G4endl;
238 G4cout << " Angle (start, span): (" << fAngle[0] / deg << ", "
239 << fAngle[1] / deg << ") [deg]" << G4endl;
240
241 G4VScoringMesh::List();
242}
G4VScoringMesh::List
virtual void List() const
Definition G4VScoringMesh.cc:305

◆ RegisterPrimitives()

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

◆ SetRMax()

void G4ScoringCylinder::SetRMax ( G4double rMax)
inline

Definition at line 55 of file G4ScoringCylinder.hh.

55{ fSize[1] = rMax; }

◆ SetRMin()

void G4ScoringCylinder::SetRMin ( G4double rMin)
inline

Definition at line 54 of file G4ScoringCylinder.hh.

54{ fSize[0] = rMin; }

◆ SetupGeometry()

void G4ScoringCylinder::SetupGeometry ( G4VPhysicalVolume * fWorldPhys)
overrideprotectedvirtual

Implements G4VScoringMesh.

Definition at line 58 of file G4ScoringCylinder.cc.

59{
60 if(verboseLevel > 9)
61 G4cout << "G4ScoringCylinder::SetupGeometry() ..." << G4endl;
62
63 // World
64 G4VPhysicalVolume* scoringWorld = fWorldPhys;
65 G4LogicalVolume* worldLogical = scoringWorld->GetLogicalVolume();
66
67 // Scoring Mesh
68 if(verboseLevel > 9)
69 G4cout << fWorldName << G4endl;
70 G4String tubsName = fWorldName + "_mesh";
71
72 if(verboseLevel > 9)
73 {
74 G4cout << "R min, R max., Dz =: " << fSize[0] << ", " << fSize[1]
75 << ", " << fSize[2] << G4endl;
76 }
77 G4VSolid* tubsSolid = new G4Tubs(tubsName + "0", // name
78 fSize[0], // R min
79 fSize[1], // R max
80 fSize[2], // Dz
81 fAngle[0], // starting phi
82 fAngle[1]); // segment phi
83 auto tubsLogical = new G4LogicalVolume(tubsSolid, nullptr, tubsName);
84 new G4PVPlacement(fRotationMatrix, fCenterPosition, tubsLogical,
85 tubsName + "0", worldLogical, false, 0);
86
87 if(verboseLevel > 9)
88 G4cout << " # of segments : r, phi, z =: " << fNSegment[IR] << ", "
89 << fNSegment[IPHI] << ", " << fNSegment[IZ] << G4endl;
90
91 G4String layerName[2] = { tubsName + "1", tubsName + "2" };
92 G4VSolid* layerSolid[2];
93 G4LogicalVolume* layerLogical[2];
94
95 //-- fisrt nested layer (replicated along z direction)
96 if(verboseLevel > 9)
97 G4cout << "layer 1 :" << G4endl;
98 layerSolid[0] = new G4Tubs(layerName[0], // name
99 fSize[0], // inner radius
100 fSize[1], // outer radius
101 fSize[2] / fNSegment[IZ], // half len. in z
102 fAngle[0], // starting phi angle
103 fAngle[1]); // delta angle of the segment
104 layerLogical[0] = new G4LogicalVolume(layerSolid[0], nullptr, layerName[0]);
105 if(fNSegment[IZ] > 1)
106 {
107 if(verboseLevel > 9)
108 G4cout << "G4ScoringCylinder::Construct() : Replicate along z direction"
109 << G4endl;
110 if(G4ScoringManager::GetReplicaLevel() > 0)
111 {
112 if(verboseLevel > 9)
113 G4cout << "G4ScoringCylinder::Construct() : Replica" << G4endl;
114 new G4PVReplica(layerName[0], layerLogical[0], tubsLogical, kZAxis,
115 fNSegment[IZ], 2. * fSize[2] / fNSegment[IZ]);
116 }
117 else
118 {
119 if(verboseLevel > 9)
120 G4cout << "G4ScoringCylinder::Construct() : Division" << G4endl;
121 new G4PVDivision(layerName[0], layerLogical[0], tubsLogical, kZAxis,
122 fNSegment[IZ], 0.);
123 }
124 }
125 else if(fNSegment[IZ] == 1)
126 {
127 if(verboseLevel > 9)
128 G4cout << "G4ScoringCylinder::Construct() : Placement" << G4endl;
129 new G4PVPlacement(nullptr, G4ThreeVector(0., 0., 0.), layerLogical[0],
130 layerName[0], tubsLogical, false, 0);
131 }
132 else
133 {
134 G4cerr << "G4ScoringCylinder::SetupGeometry() : invalid parameter ("
135 << fNSegment[IZ] << ") "
136 << "in placement of the first nested layer." << G4endl;
137 }
138
139 // second nested layer (replicated along phi direction)
140 if(verboseLevel > 9)
141 G4cout << "layer 2 :" << G4endl;
142 layerSolid[1] =
143 new G4Tubs(layerName[1], fSize[0], fSize[1], fSize[2] / fNSegment[IZ],
144 fAngle[0], fAngle[1] / fNSegment[IPHI]);
145 layerLogical[1] = new G4LogicalVolume(layerSolid[1], nullptr, layerName[1]);
146 if(fNSegment[IPHI] > 1)
147 {
148 if(verboseLevel > 9)
149 G4cout << "G4ScoringCylinder::Construct() : Replicate along phi direction"
150 << G4endl;
151 if(G4ScoringManager::GetReplicaLevel() > 1)
152 {
153 if(verboseLevel > 9)
154 G4cout << "G4ScoringCylinder::Construct() : Replica" << G4endl;
155 new G4PVReplica(layerName[1], layerLogical[1], layerLogical[0], kPhi,
156 fNSegment[IPHI], fAngle[1] / fNSegment[IPHI], fAngle[0]);
157 }
158 else
159 {
160 if(verboseLevel > 9)
161 G4cout << "G4ScoringCylinder::Construct() : Division" << G4endl;
162 new G4PVDivision(layerName[1], layerLogical[1], layerLogical[0], kPhi,
163 fNSegment[IPHI], 0.);
164 }
165 }
166 else if(fNSegment[IPHI] == 1)
167 {
168 if(verboseLevel > 9)
169 G4cout << "G4ScoringCylinder::Construct() : Placement" << G4endl;
170 new G4PVPlacement(nullptr, G4ThreeVector(0., 0., 0.), layerLogical[1],
171 layerName[1], layerLogical[0], false, 0);
172 }
173 else
174 G4cerr << "ERROR : G4ScoringCylinder::SetupGeometry() : invalid parameter ("
175 << fNSegment[IPHI] << ") "
176 << "in placement of the second nested layer." << G4endl;
177
178 // mesh elements
179 if(verboseLevel > 9)
180 G4cout << "mesh elements :" << G4endl;
181 G4String elementName = tubsName + "3";
182 G4VSolid* elementSolid = new G4Tubs(
183 elementName, fSize[0], (fSize[1] - fSize[0]) / fNSegment[IR] + fSize[0],
184 fSize[2] / fNSegment[IZ], fAngle[0], fAngle[1] / fNSegment[IPHI]);
185 fMeshElementLogical = new G4LogicalVolume(elementSolid, nullptr, elementName);
186 if(fNSegment[IR] >= 1)
187 {
188 if(verboseLevel > 9)
189 G4cout << "G4ScoringCylinder::Construct() : Replicate along r direction"
190 << G4endl;
191
192 if(G4ScoringManager::GetReplicaLevel() > 2)
193 {
194 if(verboseLevel > 9)
195 G4cout << "G4ScoringCylinder::Construct() : Replica" << G4endl;
196 new G4PVReplica(elementName, fMeshElementLogical, layerLogical[1], kRho,
197 fNSegment[IR], (fSize[1] - fSize[0]) / fNSegment[IR],
198 fSize[0]);
199 }
200 else
201 {
202 if(verboseLevel > 9)
203 G4cout << "G4ScoringCylinder::Construct() : Division" << G4endl;
204 new G4PVDivision(elementName, fMeshElementLogical, layerLogical[1], kRho,
205 fNSegment[IR], 0.);
206 }
207 }
208 else
209 {
210 G4cerr << "G4ScoringCylinder::SetupGeometry() : "
211 << "invalid parameter (" << fNSegment[IR] << ") "
212 << "in mesh element placement." << G4endl;
213 }
214
215 // set the sensitive detector
216 fMeshElementLogical->SetSensitiveDetector(fMFD);
217
218 // vis. attributes
219 auto visatt = new G4VisAttributes(G4Colour(.5, .5, .5));
220 visatt->SetVisibility(true);
221 layerLogical[0]->SetVisAttributes(visatt);
222 layerLogical[1]->SetVisAttributes(visatt);
223 visatt = new G4VisAttributes(G4Colour(.5, .5, .5, 0.01));
224 // visatt->SetForceSolid(true);
225 fMeshElementLogical->SetVisAttributes(visatt);
226
227 if(verboseLevel > 9)
228 DumpVolumes();
229}
G4ThreeVector
CLHEP::Hep3Vector G4ThreeVector
Definition G4ThreeVector.hh:36
G4LogicalVolume::SetVisAttributes
void SetVisAttributes(const G4VisAttributes *pVA)
Definition G4LogicalVolume.cc:690
G4LogicalVolume::SetSensitiveDetector
void SetSensitiveDetector(G4VSensitiveDetector *pSDetector)
Definition G4LogicalVolume.cc:478
G4ScoringManager::GetReplicaLevel
static G4int GetReplicaLevel()
Definition G4ScoringManager.cc:81
G4VPhysicalVolume::GetLogicalVolume
G4LogicalVolume * GetLogicalVolume() const
G4VScoringMesh::fMFD
G4MultiFunctionalDetector * fMFD
Definition G4VScoringMesh.hh:236
G4VScoringMesh::fMeshElementLogical
G4LogicalVolume * fMeshElementLogical
Definition G4VScoringMesh.hh:249
kPhi
@ kPhi
Definition geomdefs.hh:60
kZAxis
@ kZAxis
Definition geomdefs.hh:57
kRho
@ kRho
Definition geomdefs.hh:58

◆ SetZSize()

void G4ScoringCylinder::SetZSize ( G4double zSize)
inline

Definition at line 56 of file G4ScoringCylinder.hh.

56{ fSize[2] = zSize; } // half height
The documentation for this class was generated from the following files: