Belle II Software development
Public Member Functions | Private Member Functions | Private Attributes | List of all members
GeoARICHCreator Class Reference

The creator for the ARICH geometry of the Belle II detector. More...

#include <GeoARICHCreator.h>

Inheritance diagram for GeoARICHCreator:
CreatorBase

Public Member Functions

 GeoARICHCreator ()
 Constructor of the GeoARICHCreator class.
 
virtual ~GeoARICHCreator ()
 The destructor of the GeoARICHreator class.
 
virtual void create (const GearDir &content, G4LogicalVolume &topVolume, geometry::GeometryTypes type) override
 Creates the ROOT Objects for the ARICH geometry.
 
virtual void createPayloads (const GearDir &content, const IntervalOfValidity &iov) override
 creates DB payload for ARICHGeometryConfig class
 
virtual void createFromDB (const std::string &name, G4LogicalVolume &topVolume, geometry::GeometryTypes type) override
 Create the geometry from the Database.
 
 BELLE2_DEFINE_EXCEPTION (DBNotImplemented, "Cannot create geometry from Database.")
 Exception that will be thrown in createFromDB if member is not yet implemented by creator.
 

Private Member Functions

ARICHGeometryConfig createConfiguration (const GearDir &param)
 Reads ARICH geometry parameters from the xml files and createst DB class ARICHGeometryConfig.
 
void createGeometry (G4LogicalVolume &topVolume, geometry::GeometryTypes type)
 Create detector geometry.
 
G4LogicalVolume * buildHAPD (const ARICHGeoHAPD &hapdPar)
 build the HAPD modules
 
G4LogicalVolume * buildMerger (const ARICHGeoMerger &mergerGeo)
 build the merger PCB logical volume
 
G4LogicalVolume * buildMergerEnvelope (const ARICHGeoMerger &mergerGeo, int type)
 build single merger and merger cooling body envelope logical volume
 
G4LogicalVolume * buildCables (const ARICHGeoCablesEnvelope &cablesGeo)
 build the cables envelop with effective material describing cables
 
G4LogicalVolume * buildMirror (const ARICHGeometryConfig &detectorGeo)
 build mirrors
 
G4LogicalVolume * buildDetectorPlane (const ARICHGeometryConfig &detectorGeo)
 build detector plane
 
G4LogicalVolume * buildMergerPCBEnvelopePlane (const ARICHGeometryConfig &detectorGeo)
 build merger PCB assembly envelope plane
 
G4LogicalVolume * buildCoolingEnvelopePlane (const ARICHGeoCooling &coolingGeo)
 build cooling system assembly envelope plane
 
G4LogicalVolume * buildCoolingTube (const unsigned i_volumeID, const ARICHGeoCooling &coolingGeo)
 build cooling tube (G4Tubs)
 
G4LogicalVolume * buildCoolingTorus (const unsigned i_volumeID, const ARICHGeoCooling &coolingGeo)
 build cooling tube (G4Torus)
 
G4LogicalVolume * buildCoolingTestPlate (const ARICHGeoCooling &coolingGeo)
 build cooling test plates
 
G4LogicalVolume * buildFEBCoolingBody (const ARICHGeoFEBCooling &coolingv2Geo)
 build FEB cooling bodies (cooling system update after phase 2)
 
G4LogicalVolume * buildMergerCooling (unsigned iType)
 build merger cooling bodies (cooling system update after phase 2)
 
G4LogicalVolume * buildAerogelPlane (const ARICHGeometryConfig &detectorGeo)
 build aerogel plane
 
G4LogicalVolume * buildAerogelPlaneAveragedOverLayers (const ARICHGeometryConfig &detectorGeo)
 build aerogel plane with average properties of aerogel per layer
 
G4LogicalVolume * buildAerogelPlaneWithIndividualTilesProp (const ARICHGeometryConfig &detectorGeo)
 with individual properties of aerogel tiles
 
G4LogicalVolume * buildSimpleAerogelPlane (const ARICHGeometryConfig &detectorGeo)
 build simple aerogel plane (for cosmic test)
 
G4LogicalVolume * buildDetectorSupportPlate (const ARICHGeometryConfig &detectorGeo)
 build detector support plate
 
void makeJoint (G4Material *supportMaterial, const std::vector< double > &pars, G4AssemblyVolume *assemblyWedge)
 build joints of the ARICH support structure
 
double getAvgRINDEX (G4Material *material)
 get refractive index of the material
 

Private Attributes

ARICHGeometryConfig m_config
 geometry configuration
 
SensitiveDetector * m_sensitive
 pointer to sensitive detector
 
SensitiveAero * m_sensitiveAero
 pointer to sensitive aerogel - used instead of tracking
 
int m_isBeamBkgStudy
 flag the beam background study
 
DBObjPtr< ARICHModulesInfo > m_modInfo
 information on installed modules from the DB
 
OptionalDBObjPtr< ARICHGeoMergerCooling > m_mergerCooling
 merger cooling bodies geometry from the DB
 

Detailed Description

The creator for the ARICH geometry of the Belle II detector.


Definition at line 40 of file GeoARICHCreator.h.

Constructor & Destructor Documentation

◆ GeoARICHCreator()

GeoARICHCreator ( )

Constructor of the GeoARICHCreator class.

Definition at line 71 of file GeoARICHCreator.cc.

71 : m_isBeamBkgStudy(0)
72 {
73 m_sensitive = NULL;
74 m_sensitiveAero = NULL;
75 }
Belle2::arich::GeoARICHCreator::m_sensitiveAero
SensitiveAero * m_sensitiveAero
pointer to sensitive aerogel - used instead of tracking
Definition: GeoARICHCreator.h:169
Belle2::arich::GeoARICHCreator::m_isBeamBkgStudy
int m_isBeamBkgStudy
flag the beam background study
Definition: GeoARICHCreator.h:172
Belle2::arich::GeoARICHCreator::m_sensitive
SensitiveDetector * m_sensitive
pointer to sensitive detector
Definition: GeoARICHCreator.h:166

◆ ~GeoARICHCreator()

~GeoARICHCreator ( )
virtual

The destructor of the GeoARICHreator class.

Definition at line 77 of file GeoARICHCreator.cc.

78 {
79 delete m_sensitive;
80 delete m_sensitiveAero;
81 G4LogicalSkinSurface::CleanSurfaceTable();
82
83 }

Member Function Documentation

◆ buildAerogelPlane()

G4LogicalVolume * buildAerogelPlane ( const ARICHGeometryConfig &  detectorGeo)
private

build aerogel plane

Definition at line 495 of file GeoARICHCreator.cc.

496 {
497 if (detectorGeo.getAerogelPlane().getFullAerogelMaterialDescriptionKey() == 0)
498 return buildAerogelPlaneAveragedOverLayers(detectorGeo);
499 else if (detectorGeo.getAerogelPlane().getFullAerogelMaterialDescriptionKey() == 1)
500 return buildAerogelPlaneWithIndividualTilesProp(detectorGeo);
501 else
502 B2ERROR("GeoARICHCreator::buildAerogelPlane --> getFullAerogelMaterialDescriptionKey() is wrong");
503 return NULL;
504 }
Belle2::arich::GeoARICHCreator::buildAerogelPlaneAveragedOverLayers
G4LogicalVolume * buildAerogelPlaneAveragedOverLayers(const ARICHGeometryConfig &detectorGeo)
build aerogel plane with average properties of aerogel per layer
Definition: GeoARICHCreator.cc:506
Belle2::arich::GeoARICHCreator::buildAerogelPlaneWithIndividualTilesProp
G4LogicalVolume * buildAerogelPlaneWithIndividualTilesProp(const ARICHGeometryConfig &detectorGeo)
with individual properties of aerogel tiles
Definition: GeoARICHCreator.cc:616

◆ buildAerogelPlaneAveragedOverLayers()

G4LogicalVolume * buildAerogelPlaneAveragedOverLayers ( const ARICHGeometryConfig &  detectorGeo)
private

build aerogel plane with average properties of aerogel per layer

Definition at line 506 of file GeoARICHCreator.cc.

507 {
508
509 //cout<<"GeoARICHCreator::buildAerogelPlaneAveragedOverLayers(const ARICHGeometryConfig& detectorGeo)"<<endl;
510
511 const ARICHGeoAerogelPlane& aeroGeo = detectorGeo.getAerogelPlane();
512
513 // support plane
514 double rin = aeroGeo.getSupportInnerR();
515 double rout = aeroGeo.getSupportOuterR();
516 double thick = aeroGeo.getSupportThickness();
517 double wallThick = aeroGeo.getWallThickness();
518 double wallHeight = aeroGeo.getWallHeight();
519 string supportMat = aeroGeo.getSupportMaterial();
520 G4Material* supportMaterial = Materials::get(supportMat);
521 G4Material* gapMaterial = Materials::get("Air"); // Air without refractive index (to kill photons, to mimic black paper around tile)
522 G4Material* imgMaterial = Materials::get("ARICH_Air");
523 // master volume
524
525 //double imgTubeLen = 0.5; // if changed, change position of aerogel plane also in main function!!
526 double imgTubeLen = aeroGeo.getImgTubeThickness();
527 G4Tubs* aerogelTube = new G4Tubs("aerogelTube", rin, rout, (thick + wallHeight + imgTubeLen) / 2., 0, 2 * M_PI);
528 G4LogicalVolume* aerogelPlaneLV = new G4LogicalVolume(aerogelTube, gapMaterial, "ARICH.AaerogelPlane");
529
530 // support plate
531 G4Tubs* supportTube = new G4Tubs("aeroSupportTube", rin, rout, thick / 2., 0, 2 * M_PI);
532 G4LogicalVolume* supportTubeLV = new G4LogicalVolume(supportTube, supportMaterial, "ARICH.AerogelSupportPlate");
533 //supportTubeLV->SetSensitiveDetector(m_sensitiveAero);
534
535 // imaginary tube after aerogel layers (used as volume to which tracks are extrapolated by ext module)
536 G4Tubs* imgTube = new G4Tubs("imgTube", rin, rout, imgTubeLen / 2., 0, 2 * M_PI);
537 G4LogicalVolume* imgTubeLV = new G4LogicalVolume(imgTube, imgMaterial, "ARICH.AerogelImgPlate");
538 imgTubeLV->SetSensitiveDetector(m_sensitiveAero);
539
540
541 // read radiuses of aerogel slot aluminum walls
542 std::vector<double> wallR;
543 unsigned nRing = aeroGeo.getNRings();
544 for (unsigned iRing = 1; iRing < nRing + 1; iRing++) {
545 wallR.push_back(aeroGeo.getRingRadius(iRing));
546 }
547
548 unsigned nLayer = aeroGeo.getNLayers();
549 double tileGap = aeroGeo.getTileGap();
550 G4Transform3D transform = G4Translate3D(0., 0., (thick - imgTubeLen) / 2.);
551
552 for (unsigned iRing = 0; iRing < nRing; iRing++) {
553
554 // aluminum walls between tile rings (r wall)
555 std::stringstream wallName;
556 wallName << "supportWallR_" << iRing + 1;
557 G4Tubs* supportWall = new G4Tubs(wallName.str().c_str(), wallR[iRing], wallR[iRing] + wallThick, wallHeight / 2., 0, 2 * M_PI);
558 G4LogicalVolume* supportWallLV = new G4LogicalVolume(supportWall, supportMaterial, string("ARICH.") + wallName.str().c_str());
559
560 new G4PVPlacement(transform, supportWallLV, string("ARICH.") + wallName.str().c_str(), aerogelPlaneLV, false, 0);
561
562 if (iRing == 0) continue;
563
564 // place phi aluminum walls
565 double dphi = aeroGeo.getRingDPhi(iRing);
566
567 wallName.str("");
568 wallName << "supportWallPhi_" << iRing + 1;
569 G4Box* wall = new G4Box(wallName.str(), (wallR[iRing] - wallR[iRing - 1] - wallThick) / 2. - 1., thick / 2., wallHeight / 2.);
570 G4LogicalVolume* wallLV = new G4LogicalVolume(wall, supportMaterial, string("ARICH.") + wallName.str());
571 double r = (wallR[iRing - 1] + wallThick + wallR[iRing]) / 2.;
572 double zLayer = 0;
573
574 // loop over layers
575 int iSlot = 1;
576 for (unsigned iLayer = 1; iLayer < nLayer + 1; iLayer++) {
577 double iphi = 0;
578 double layerThick = aeroGeo.getLayerThickness(iLayer);
579
580 std::stringstream tileName;
581 tileName << "aerogelTile_" << iRing << "_" << iLayer;
582
583 G4Tubs* tileShape = new G4Tubs(tileName.str(), wallR[iRing - 1] + wallThick + tileGap, wallR[iRing] - tileGap, layerThick / 2.,
584 (tileGap + wallThick / 2.) / wallR[iRing], dphi - (2.*tileGap + wallThick) / wallR[iRing]);
585
586 G4Material* aeroMaterial = Materials::get(aeroGeo.getLayerMaterial(iLayer));
587 G4LogicalVolume* tileLV = new G4LogicalVolume(tileShape, aeroMaterial, string("ARICH.") + tileName.str());
588
589 while (iphi < 2 * M_PI - 0.0001) {
590 G4ThreeVector trans(r * cos(iphi), r * sin(iphi), (thick - imgTubeLen) / 2.);
591 G4RotationMatrix Ra;
592 Ra.rotateZ(iphi);
593
594 if (iLayer == 1) new G4PVPlacement(G4Transform3D(Ra, trans), wallLV, string("ARICH.") + wallName.str(), aerogelPlaneLV, false,
595 iSlot);
596
597 G4ThreeVector transTile(0, 0, (thick + layerThick - wallHeight - imgTubeLen) / 2. + zLayer);
598 new G4PVPlacement(G4Transform3D(Ra, transTile), tileLV, string("ARICH.") + tileName.str(), aerogelPlaneLV, false, iSlot);
599 iphi += dphi;
600 iSlot++;
601 }
602 zLayer += layerThick;
603 }
604 }
605
606 new G4PVPlacement(G4Translate3D(0., 0., -(wallHeight + imgTubeLen) / 2.), supportTubeLV, "ARICH.AerogelSupportPlate",
607 aerogelPlaneLV,
608 false, 1);
609
610 new G4PVPlacement(G4Translate3D(0., 0., (wallHeight + thick) / 2.), imgTubeLV, "ARICH.AerogelImgPlate", aerogelPlaneLV, false, 1);
611
612 return aerogelPlaneLV;
613
614 }
Belle2::geometry::Materials::get
static G4Material * get(const std::string &name)
Find given material.
Definition: Materials.h:63

◆ buildAerogelPlaneWithIndividualTilesProp()

G4LogicalVolume * buildAerogelPlaneWithIndividualTilesProp ( const ARICHGeometryConfig &  detectorGeo)
private

with individual properties of aerogel tiles

Definition at line 616 of file GeoARICHCreator.cc.

617 {
618
619 //cout << "GeoARICHCreator::buildAerogelPlaneWithIndividualTilesProp(const ARICHGeometryConfig& detectorGeo)" << endl;
620
621 const ARICHGeoAerogelPlane& aeroGeo = detectorGeo.getAerogelPlane();
622
623 // support plane
624 double rin = aeroGeo.getSupportInnerR();
625 double rout = aeroGeo.getSupportOuterR();
626 double thick = aeroGeo.getSupportThickness();
627 double wallThick = aeroGeo.getWallThickness();
628 // Maximum total (up and down) thickness of the aerogel tiles
629 double maxTotalAerogelThick = aeroGeo.getMaximumTotalTileThickness();
630 //cout<<"maxTotalAerogelThick "<<maxTotalAerogelThick<<endl
631 // <<"wallHeight "<<wallHeight<<endl;
632 // In case of individual thickness of the tiles we need to define compensation
633 // volume with ARICH air. This volume situated between aerogel tile and image plane (imgTube).
634 // Minimum thickness of the compensation volume with ARICH air
635 double compensationARICHairVolumeThick_min = aeroGeo.getCompensationARICHairVolumeThick_min(); // mm
636 // Please note redefinition of wallHeight value
637 double wallHeight = maxTotalAerogelThick + compensationARICHairVolumeThick_min;
638
639 string supportMat = aeroGeo.getSupportMaterial();
640 G4Material* supportMaterial = Materials::get(supportMat);
641
642 G4Material* gapMaterial =
643 Materials::get("Air"); // Air without refractive index (to kill photons, to mimic black paper around tile)
644 G4Material* imgMaterial = Materials::get("ARICH_Air"); // Air with defined optical properties to propagate cherenkov photons
645
646 // master volume
647 double imgTubeLen = aeroGeo.getImgTubeThickness(); // if changed, change position of aerogel plane also in main function!!
648 G4Tubs* aerogelTube = new G4Tubs("aerogelTube", rin, rout, (thick + wallHeight + imgTubeLen) / 2., 0, 2 * M_PI);
649 G4LogicalVolume* aerogelPlaneLV = new G4LogicalVolume(aerogelTube, gapMaterial, "ARICH.AaerogelPlane");
650
651 // support plate
652 G4Tubs* supportTube = new G4Tubs("aeroSupportTube", rin, rout, thick / 2., 0, 2 * M_PI);
653 G4LogicalVolume* supportTubeLV = new G4LogicalVolume(supportTube, supportMaterial, "ARICH.AerogelSupportPlate");
654 //supportTubeLV->SetSensitiveDetector(m_sensitiveAero);
655
656 // imaginary tube after aerogel layers (used as volume to which tracks are extrapolated by ext module)
657 G4Tubs* imgTube = new G4Tubs("imgTube", rin, rout, imgTubeLen / 2., 0, 2 * M_PI);
658 G4LogicalVolume* imgTubeLV = new G4LogicalVolume(imgTube, imgMaterial, "ARICH.AerogelImgPlate");
659 imgTubeLV->SetSensitiveDetector(m_sensitiveAero);
660
661 // read radiuses of aerogel slot aluminum walls
662 std::vector<double> wallR;
663 unsigned nRing = aeroGeo.getNRings();
664 for (unsigned iRing = 1; iRing < nRing + 1; iRing++) {
665 wallR.push_back(aeroGeo.getRingRadius(iRing));
666 }
667
668 unsigned nLayer = aeroGeo.getNLayers();
669 double tileGap = aeroGeo.getTileGap();
670 G4Transform3D transform = G4Translate3D(0., 0., (thick - imgTubeLen) / 2.);
671
672 for (unsigned iRing = 0; iRing < nRing; iRing++) {
673
674 // Aluminum walls between tile rings (r wall)
675 std::stringstream wallName;
676 wallName << "supportWallR_" << iRing + 1;
677 //cout<<"wallName = "<<wallName.str().c_str()<<endl;
678 G4Tubs* supportWall = new G4Tubs(wallName.str().c_str(), wallR[iRing], wallR[iRing] + wallThick, wallHeight / 2., 0, 2 * M_PI);
679 G4LogicalVolume* supportWallLV = new G4LogicalVolume(supportWall, supportMaterial, string("ARICH.") + wallName.str().c_str());
680 new G4PVPlacement(transform, supportWallLV, string("ARICH.") + wallName.str().c_str(), aerogelPlaneLV, false, 0);
682
683 // There are only 4 rings of aerogel - the first one is only for mechanical support
684 if (iRing == 0) continue;
685
686 // dphi - distance between centers of two consecutive aluminum walls (diaphragm) in one ring
687 double dphi = aeroGeo.getRingDPhi(iRing);
688
689 // Aluminum walls (diaphragm) between two neighboring tile in one ring (phi wall)
690 wallName.str("");
691 wallName << "supportWallPhi_" << iRing + 1;
692 G4Box* wall = new G4Box(wallName.str(), (wallR[iRing] - wallR[iRing - 1] - wallThick) / 2. - 1., thick / 2., wallHeight / 2.);
693 G4LogicalVolume* wallLV = new G4LogicalVolume(wall, supportMaterial, string("ARICH.") + wallName.str());
694 double r = (wallR[iRing - 1] + wallThick + wallR[iRing]) / 2.;
696
697 // loop over layers
698 int icopyNumber = 0;
699 for (unsigned iLayer = 1; iLayer < nLayer + 1; iLayer++) {
700 //int iSlot = 1;
701 double iphi = 0;
702
703 int iicolumn = 0;
704 // loop over phi (over tile slots from same ring)
705 while (iphi < 2 * M_PI - 0.0001) {
706
707 // Define layer thickness as -1 in case it will not be defined
708 // below in the code with a appropriate value - Geant4 will trigger error
709 double layerThick = -1.0;
710 double tileUpThick = -1.0;
711 double tileDownThick = -1.0;
712 //cout<<" double layerThick = aeroGeo.getLayerThickness(iLayer) = "<<layerThick<<endl;
713
714 // Define material and thickness
715 G4Material* aeroMaterial = NULL;
716 int ati_ring = iRing;
717 int ati_column = iicolumn + 1;
718 int ati_layerN = iLayer - 1;
719
720 //cout<<setw(5)<<ati_layerN<<setw(5)<<ati_ring<<setw(5)<<ati_column<<endl;
721 if (detectorGeo.getAerogelPlane().getFullAerogelMaterialDescriptionKey() == 1) {
722 aeroMaterial = Materials::get(aeroGeo.getTileMaterialName(ati_ring, ati_column, ati_layerN).c_str());
723 } else {
724 B2ERROR("GeoARICHCreator::buildAerogelPlaneWithIndividualTilesProp --> getFullAerogelMaterialDescriptionKey() is wrong");
725 }
726 //cout<<"-----------------"<<endl
727 // <<"iLayer = "<<iLayer<<endl
728 // <<aeroMaterial->GetName()<<endl;
729 //cout<<setw(5)<<ati_layerN<<setw(5)<<ati_ring<<setw(5)<<ati_column<<endl;
730 //aeroMaterial->GetMaterialPropertiesTable()->DumpTable();
731 //zcout<<"ooooooooooooooooo"<<endl;
732 layerThick = aeroGeo.getTileThickness(ati_ring, ati_column, ati_layerN);
733 tileUpThick = aeroGeo.getTileThickness(ati_ring, ati_column, 0);
734 tileDownThick = aeroGeo.getTileThickness(ati_ring, ati_column, 1);
735
736 // Placement of the aluminum walls (diaphragm) between two neighboring tile in one ring (phi wall)
737 // please note that we place single wall for two aerogel layers
738 G4ThreeVector trans(r * cos(iphi), r * sin(iphi), (thick - imgTubeLen) / 2.);
739 G4RotationMatrix Ra;
740 Ra.rotateZ(iphi);
741 if (iLayer == 1) {
742 new G4PVPlacement(G4Transform3D(Ra, trans), //transformation
743 wallLV, //its logical
744 string("ARICH.") + wallName.str(), //name
745 aerogelPlaneLV, //mother logical
746 false, //always false
747 icopyNumber); //should be set to 0 for the first volume of a given type.
749
750 // In case of individual thickness
751 // (if aeroGeo.getFullAerogelMaterialDescriptionKey() == 1) or
752 // (if aeroGeo.getFullAerogelMaterialDescriptionKey() == 2)
753 // of the tiles we need to define compensation volume with ARICH air.
754 // This volume situated between aerogel tile and image plane (imgTube).
755 // This volume have same shape as earogel tile but different thickness.
756 // Build Compensation tiles only one time
757 // Compensation tile shape
758 double compTileUpThick = wallHeight - tileUpThick - tileDownThick;
759 std::stringstream compTileName;
760 //compTileName << "aerogelCompTile_" << ati_layerN << "_" << ati_ring << "_" << ati_column;
761 // In the end of the name we have Layer(L), Ring(R), Slot/Column(S) id's
762 // L : 1-2
763 // R : 1-4
764 // S : 1-22 @ R = 1
765 // S : 1-28 @ R = 2
766 // S : 1-34 @ R = 3
767 // S : 1-40 @ R = 4
768 compTileName << "aerogelCompTile_" << iLayer << "_" << ati_ring << "_" << ati_column;
769 //cout<<compTileName.str()<<endl;
770 G4Tubs* compTileShape = new G4Tubs(compTileName.str(), //name
771 wallR[iRing - 1] + wallThick + tileGap, //Rmin
772 wallR[iRing] - tileGap, //Rmax
773 compTileUpThick / 2.0, //Thikness
774 (tileGap + wallThick / 2.0) / wallR[iRing], //phi start
775 dphi - (2.0 * tileGap + wallThick) / wallR[iRing]); //delta phi
776
777 // Logical volume of the compensation tiles
778 G4LogicalVolume* compTileLV = new G4LogicalVolume(compTileShape, //Its solid
779 imgMaterial, //G4 material
780 string("ARICH.") + compTileName.str()); //name
781
782 // Placement of the compensation tiles
783 G4ThreeVector transCompTile(0, 0, (thick + wallHeight - compTileUpThick - imgTubeLen) / 2.0);
784 G4RotationMatrix compRa;
785 compRa.rotateZ(iphi);
786 new G4PVPlacement(G4Transform3D(compRa, transCompTile), //transformation
787 compTileLV, //its logical
788 string("ARICH.") + compTileName.str(), //name
789 aerogelPlaneLV, //mother logical
790 false, //always false
791 0); //should be set to 0 for the first volume of a given type.
792 }
793
794 // Tile shape
795 std::stringstream tileName;
796 tileName << "aerogelTile_" << iLayer << "_" << ati_ring << "_" << ati_column;
797 //cout<<tileName.str()<<endl;
798 G4Tubs* tileShape = new G4Tubs(tileName.str(), //name
799 wallR[iRing - 1] + wallThick + tileGap, //Rmin
800 wallR[iRing] - tileGap, //Rmax
801 layerThick / 2.0, //Thikness
802 (tileGap + wallThick / 2.0) / wallR[iRing], //phi start
803 dphi - (2.0 * tileGap + wallThick) / wallR[iRing]); //delta phi
804
805 // Logical volume of the aerogel tiles
806 G4LogicalVolume* tileLV = new G4LogicalVolume(tileShape, //Its solid
807 aeroMaterial, //G4 material
808 string("ARICH.") + tileName.str()); //name
809
810 // Placement of the aerogel tiles
811 double zLayer = 0.0;
812 if (iLayer == 2)
813 zLayer = tileUpThick;
814 G4ThreeVector transTile(0, 0, (thick + layerThick - wallHeight - imgTubeLen) / 2.0 + zLayer);
815 new G4PVPlacement(G4Transform3D(Ra, transTile), //transformation
816 tileLV, //its logical
817 string("ARICH.") + tileName.str(), //name
818 aerogelPlaneLV, //mother logical
819 false, //always false
820 0); //should be set to 0 for the first volume of a given type.
822
823 iphi += dphi;
824 //iSlot++;
825 icopyNumber++;
826 iicolumn++;
827 }
828 }
829 }
830
831 // Placement of the support tube
832 new G4PVPlacement(G4Translate3D(0., 0., -(wallHeight + imgTubeLen) / 2.), //transformation
833 supportTubeLV, //its logical
834 "ARICH.AerogelSupportPlate", //name
835 aerogelPlaneLV, //mother logical
836 false, //always false
837 0); //should be set to 0 for the first volume of a given type.
838
839 // Placement of the imaginary tube after aerogel layers (used as volume to which tracks are extrapolated by ext module)
840 new G4PVPlacement(G4Translate3D(0., 0., (wallHeight + thick) / 2.), //transformation
841 imgTubeLV, //its logical
842 "ARICH.AerogelImgPlate", //name
843 aerogelPlaneLV, //mother logical
844 false, //always false
845 0); //should be set to 0 for the first volume of a given type.
846
847 return aerogelPlaneLV;
848
849 }

◆ buildCables()

G4LogicalVolume * buildCables ( const ARICHGeoCablesEnvelope &  cablesGeo)
private

build the cables envelop with effective material describing cables

Definition at line 1169 of file GeoARICHCreator.cc.

1170 {
1171
1172 G4Tubs* cablesEnvelope_solid = new G4Tubs("cablesEnvelope_solid",
1173 cablesGeo.getEnvelopeInnerRadius(),
1174 cablesGeo.getEnvelopeOuterRadius(),
1175 cablesGeo.getEnvelopeThickness() / 2.0,
1176 0.0,
1177 2.0 * M_PI);
1178 G4LogicalVolume* cablesEnvelope_logical = new G4LogicalVolume(cablesEnvelope_solid,
1179 Materials::get(cablesGeo.getCablesEffectiveMaterialName()),
1180 "ARICH.cablesEnvelope");
1181
1182 return cablesEnvelope_logical;
1183
1184 }

◆ buildCoolingEnvelopePlane()

G4LogicalVolume * buildCoolingEnvelopePlane ( const ARICHGeoCooling &  coolingGeo)
private

build cooling system assembly envelope plane

Definition at line 1337 of file GeoARICHCreator.cc.

1338 {
1339
1340 G4Tubs* coolingEnvelope_solid = new G4Tubs("coolingEnvelope_solid",
1341 coolingGeo.getEnvelopeInnerRadius(),
1342 coolingGeo.getEnvelopeOuterRadius(),
1343 coolingGeo.getEnvelopeThickness() / 2.0,
1344 0.0,
1345 2.0 * M_PI);
1346 G4LogicalVolume* coolingEnvelope_logical = new G4LogicalVolume(coolingEnvelope_solid,
1347 Materials::get("Air"),
1348 "ARICH.coolingEnvelope");
1349
1350 unsigned nComponents = coolingGeo.getCoolingGeometryID().size();
1351
1352 for (unsigned i = 0; i < nComponents; i++) {
1353 double r = coolingGeo.getCoolingPosR().at(i) * mm;
1354 double phi = coolingGeo.getCoolingPosPhi().at(i) * deg;
1355 G4ThreeVector Ta;
1356 G4RotationMatrix Ra;
1357 G4LogicalVolume* coolingComponentLV;
1358 if (coolingGeo.getCoolingGeometryID().at(i) == 1) {
1359 //<!-- 1 -> G4Tubs --> build a tube
1360 Ta.set(r * cos(phi), r * sin(phi), 0);
1361 //First need to rotate around y axis
1362 //to make the tube parallel with x axis
1363 Ra.rotateY(90.0 * deg);
1364 Ra.rotateZ(coolingGeo.getCoolinRotationAngle().at(i) * deg);
1365 coolingComponentLV = buildCoolingTube(i, coolingGeo);
1366 } else if (coolingGeo.getCoolingGeometryID().at(i) == 2) {
1367 //<!-- 2 -> G4Torus --> build a torus
1368 coolingComponentLV = buildCoolingTorus(i, coolingGeo);
1369 } else {
1370 B2FATAL("ARICH cooling geometry component ID is wrong");
1371 }
1372 new G4PVPlacement(G4Transform3D(Ra, Ta), //Transformation
1373 coolingComponentLV, //its logical volume
1374 "ARICH.cooling", //its name
1375 coolingEnvelope_logical, //its mother volume
1376 false, //no boolean operation
1377 i); //copy number
1378 }
1379
1380 return coolingEnvelope_logical;
1381
1382 }
Belle2::arich::GeoARICHCreator::buildCoolingTorus
G4LogicalVolume * buildCoolingTorus(const unsigned i_volumeID, const ARICHGeoCooling &coolingGeo)
build cooling tube (G4Torus)
Definition: GeoARICHCreator.cc:1315
Belle2::arich::GeoARICHCreator::buildCoolingTube
G4LogicalVolume * buildCoolingTube(const unsigned i_volumeID, const ARICHGeoCooling &coolingGeo)
build cooling tube (G4Tubs)
Definition: GeoARICHCreator.cc:1300

◆ buildCoolingTestPlate()

G4LogicalVolume * buildCoolingTestPlate ( const ARICHGeoCooling &  coolingGeo)
private

build cooling test plates

Definition at line 1384 of file GeoARICHCreator.cc.

1385 {
1386
1387 G4Box* coolingTestPlateEnvelop_solid = new G4Box("coolingTestPlateEnvelop_solid",
1388 coolingGeo.getCoolingTestPlateslengths().X() / 2.0 * mm,
1389 coolingGeo.getCoolingTestPlateslengths().Y() / 2.0 * mm,
1390 coolingGeo.getCoolingTestPlateslengths().Z() / 2.0 * mm);
1391 G4LogicalVolume* coolingTestPlateEnvelop_logical = new G4LogicalVolume(coolingTestPlateEnvelop_solid, Materials::get("Air"),
1392 "ARICH.coolingTestPlateEnvelop");
1393
1394 G4Box* coolingTestPlate_solid = new G4Box("coolingTestPlate_solid",
1395 coolingGeo.getCoolingTestPlateslengths().X() / 2.0 * mm,
1396 coolingGeo.getCoolingTestPlateslengths().Y() / 2.0 * mm,
1397 coolingGeo.getCoolingTestPlateslengths().Z() / 2.0 * mm);
1398
1399 // Volume to subtract
1400 G4VSolid* coldTubeSubtracted_solid = new G4Tubs("coldTubeSubtracted_solid",
1401 0.0,
1402 coolingGeo.getColdTubeSubtractedR() * mm,
1403 (coolingGeo.getCoolingTestPlateslengths().X() + 1) / 2.0 * mm,
1404 0, 360.0 * deg);
1405
1406 // Volume to add (cold tube)
1407 G4VSolid* coldTube_solid = new G4Tubs("coldTube_solid",
1408 (coolingGeo.getColdTubeR() - coolingGeo.getColdTubeWallThickness()) * mm,
1409 coolingGeo.getColdTubeR() * mm,
1410 coolingGeo.getCoolingTestPlateslengths().X() / 2.0 * mm,
1411 0, 360.0 * deg);
1412 G4LogicalVolume* coldTube_logical = new G4LogicalVolume(coldTube_solid, Materials::get(coolingGeo.getColdTubeMaterialName()),
1413 "ARICH.coldTube");
1414
1415 G4RotationMatrix Ra_sub;
1416 G4ThreeVector Ta_sub;
1417 G4Transform3D Tr_sub;
1418 Ta_sub.setX(0.0);
1419 Ta_sub.setY((coolingGeo.getCoolingTestPlateslengths().Y() / 2.0 - coolingGeo.getColdTubeSpacing()) * mm);
1420 Ta_sub.setZ((coolingGeo.getCoolingTestPlateslengths().Z() / 2.0 - coolingGeo.getDepthColdTubeInPlate()) * mm);
1421 Ra_sub.rotateY(90.0 * deg);
1422 Tr_sub = G4Transform3D(Ra_sub, Ta_sub);
1423 G4SubtractionSolid* substraction_solid = new G4SubtractionSolid("substraction_solid", coolingTestPlate_solid,
1424 coldTubeSubtracted_solid, Tr_sub);
1425 for (int i = 1; i < coolingGeo.getColdTubeNumber(); i++) {
1426 Ta_sub.setX(0.0);
1427 Ta_sub.setY((coolingGeo.getCoolingTestPlateslengths().Y() / 2.0 - coolingGeo.getColdTubeSpacing() - coolingGeo.getColdTubeSpacing()
1428 * 2 * i) * mm);
1429 Ta_sub.setZ((coolingGeo.getCoolingTestPlateslengths().Z() / 2.0 - coolingGeo.getDepthColdTubeInPlate()) * mm);
1430 Tr_sub = G4Transform3D(Ra_sub, Ta_sub);
1431 substraction_solid = new G4SubtractionSolid("substraction_solid", substraction_solid, coldTubeSubtracted_solid, Tr_sub);
1432 }
1433
1434 G4LogicalVolume* coolingTestPlate_logical = new G4LogicalVolume(substraction_solid,
1435 Materials::get(coolingGeo.getCoolingTestPlateMaterialName()), "ARICH.coolingTestPlate");
1436
1437 new G4PVPlacement(G4Transform3D(), //Transformation
1438 coolingTestPlate_logical, //its logical volume
1439 "ARICH.coolingTestPlate", //its name
1440 coolingTestPlateEnvelop_logical, //its mother volume
1441 false, //no boolean operation
1442 0); //copy number
1443 //Add cold tubes
1444 G4RotationMatrix Ra;
1445 G4ThreeVector Ta;
1446 G4Transform3D Tr;
1447 Ra.rotateY(90.0 * deg);
1448 for (int i = 0; i < coolingGeo.getColdTubeNumber(); i++) {
1449 Ta.setX(0.0);
1450 Ta.setY((coolingGeo.getCoolingTestPlateslengths().Y() / 2.0 - coolingGeo.getColdTubeSpacing() - coolingGeo.getColdTubeSpacing() *
1451 2 * i) * mm);
1452 Ta.setZ((coolingGeo.getCoolingTestPlateslengths().Z() / 2.0 - coolingGeo.getDepthColdTubeInPlate()) * mm);
1453 Tr = G4Transform3D(Ra, Ta);
1454 new G4PVPlacement(Tr, //Transformation
1455 coldTube_logical, //its logical volume
1456 "ARICH.coldTube", //its name
1457 coolingTestPlateEnvelop_logical, //its mother volume
1458 false, //no boolean operation
1459 0); //copy number
1460 }
1461
1462 return coolingTestPlateEnvelop_logical;
1463
1464 }

◆ buildCoolingTorus()

G4LogicalVolume * buildCoolingTorus ( const unsigned  i_volumeID,
const ARICHGeoCooling &  coolingGeo 
)
private

build cooling tube (G4Torus)

Definition at line 1315 of file GeoARICHCreator.cc.

1316 {
1317
1318 B2ASSERT("ARICH cooling geometry ID (G4Torus) is wrong : coolingGeo.getCoolingGeometryID.at(i_volumeID) != 2",
1319 coolingGeo.getCoolingGeometryID().at(i_volumeID) == 2);
1320
1321 double pSPhi = coolingGeo.getCoolingPosPhi().at(i_volumeID) * deg - coolingGeo.getCoolingL().at(
1322 i_volumeID) / coolingGeo.getCoolingPosR().at(i_volumeID) / 2.0;
1323 //double pDPhi = coolingGeo.getCoolingPosPhi().at(i_volumeID)*deg + coolingGeo.getCoolingL().at(i_volumeID) / coolingGeo.getCoolingPosR().at(i_volumeID) / 2.0;
1324 double pDPhi = coolingGeo.getCoolingL().at(i_volumeID) / coolingGeo.getCoolingPosR().at(i_volumeID);
1325
1326 G4Torus* coolingTorus_solid = new G4Torus("coolingTorus_solid", // name
1327 coolingGeo.getRmin(), // pRmin
1328 coolingGeo.getRmax(), // pRmax
1329 coolingGeo.getCoolingPosR().at(i_volumeID), // pRtor
1330 pSPhi, // pSPhi
1331 pDPhi); // pDPhi
1332
1333 return new G4LogicalVolume(coolingTorus_solid, Materials::get(coolingGeo.getCoolingPipeMaterialName()), "ARICH.coolingTorus");
1334
1335 }

◆ buildCoolingTube()

G4LogicalVolume * buildCoolingTube ( const unsigned  i_volumeID,
const ARICHGeoCooling &  coolingGeo 
)
private

build cooling tube (G4Tubs)

Definition at line 1300 of file GeoARICHCreator.cc.

1301 {
1302
1303 B2ASSERT("ARICH cooling geometry ID (G4Tube) is wrong : coolingGeo.getCoolingGeometryID.at(i_volumeID) != 1",
1304 coolingGeo.getCoolingGeometryID().at(i_volumeID) == 1);
1305 G4Tubs* coolingTube_solid = new G4Tubs("coolingTube_solid",
1306 coolingGeo.getRmin() * mm,
1307 coolingGeo.getRmax() * mm,
1308 coolingGeo.getCoolingL().at(i_volumeID) * mm / 2.0,
1309 0.0,
1310 2.0 * M_PI);
1311 return new G4LogicalVolume(coolingTube_solid, Materials::get(coolingGeo.getCoolingPipeMaterialName()), "ARICH.coolingTube");
1312
1313 }

◆ buildDetectorPlane()

G4LogicalVolume * buildDetectorPlane ( const ARICHGeometryConfig &  detectorGeo)
private

build detector plane

Definition at line 946 of file GeoARICHCreator.cc.

947 {
948
949 const ARICHGeoHAPD& hapdGeo = detectorGeo.getHAPDGeometry();
950 G4LogicalVolume* hapdLV = buildHAPD(hapdGeo);
951
952 const ARICHGeoDetectorPlane& detGeo = detectorGeo.getDetectorPlane();
953
954 G4Tubs* detTube = new G4Tubs("detTube", detGeo.getRingR(1) - hapdGeo.getSizeX() * 1.4 / 2.,
955 detGeo.getRingR(detGeo.getNRings()) + hapdGeo.getSizeX() * 1.4 / 2., hapdGeo.getModuleSizeZ() / 2., 0, 2 * M_PI);
956 G4LogicalVolume* detPlaneLV = new G4LogicalVolume(detTube, Materials::get("ARICH_Air"), "ARICH.detectorPlane");
957
958 unsigned nSlots = detGeo.getNSlots();
959
960 for (unsigned iSlot = 1; iSlot < nSlots + 1; iSlot++) {
961 if (!m_modInfo->isInstalled(iSlot)) continue;
962 double r = detGeo.getSlotR(iSlot);
963 double phi = detGeo.getSlotPhi(iSlot);
964 G4ThreeVector trans(r * cos(phi), r * sin(phi), 0);
965 G4RotationMatrix Ra;
966 Ra.rotateZ(phi);
967 G4ThreeVector trans1(r * cos(phi), r * sin(phi), 0.0);
968 new G4PVPlacement(G4Transform3D(Ra, trans1), hapdLV, "ARICH.HAPDModule", detPlaneLV, false, iSlot);
969 }
970
971 return detPlaneLV;
972
973 }
Belle2::arich::GeoARICHCreator::buildHAPD
G4LogicalVolume * buildHAPD(const ARICHGeoHAPD &hapdPar)
build the HAPD modules
Definition: GeoARICHCreator.cc:851
Belle2::arich::GeoARICHCreator::m_modInfo
DBObjPtr< ARICHModulesInfo > m_modInfo
information on installed modules from the DB
Definition: GeoARICHCreator.h:174

◆ buildDetectorSupportPlate()

G4LogicalVolume * buildDetectorSupportPlate ( const ARICHGeometryConfig &  detectorGeo)
private

build detector support plate

Definition at line 1466 of file GeoARICHCreator.cc.

1467 {
1468
1469 const ARICHGeoDetectorPlane& detGeo = detectorGeo.getDetectorPlane();
1470
1471 G4Tubs* supportTube = new G4Tubs("supportTube", detGeo.getSupportInnerR(), detGeo.getSupportOuterR(),
1472 (detGeo.getSupportThickness() + detGeo.getSupportBackWallHeight()) / 2., 0, 2 * M_PI);
1473 G4Material* supportMaterial = Materials::get(detGeo.getSupportMaterial());
1474 G4LogicalVolume* detSupportLV = new G4LogicalVolume(supportTube, supportMaterial, "ARICH.detectorSupportPlate");
1475
1476 G4Tubs* supportPlate = new G4Tubs("supportPlate", detGeo.getSupportInnerR(), detGeo.getSupportOuterR(),
1477 detGeo.getSupportThickness() / 2., 0, 2 * M_PI);
1478
1479 G4Box* hole = new G4Box("hole", detGeo.getModuleHoleSize() / 2., detGeo.getModuleHoleSize() / 2.,
1480 detGeo.getSupportThickness() / 2.); // +1 for thickness for subtraction solid
1481 G4LogicalVolume* holeLV = new G4LogicalVolume(hole, Materials::get("Air"), "ARICH.detectorSupportHole");
1482
1483 int nRings = detGeo.getNRings();
1484 std::vector<G4LogicalVolume*> hapdBackRadialWallLV;
1485 double backWallThick = detGeo.getSupportBackWallThickness();
1486 double backWallHeight = detGeo.getSupportBackWallHeight();
1487
1488 G4LogicalVolume* hapdSupportPlateLV = new G4LogicalVolume(supportPlate, supportMaterial, "hapdSupport");
1489
1490 std::vector<double> wallR;
1491 wallR.assign(nRings + 1, 0);
1492 std::vector<double> thickR;
1493 thickR.assign(nRings + 1, 0);
1494
1495 for (int i = 1; i < nRings; i++) {
1496 double rm1 = detGeo.getRingR(i);
1497 double rp1 = detGeo.getRingR(i + 1);
1498 wallR[i] = (rp1 + rm1) / 2.;
1499 if (i == 1) {
1500 wallR[0] = rm1 - (rp1 - rm1) / 2.;
1501 }
1502 if (i == nRings - 1) {
1503 wallR[i + 1] = rp1 + (rp1 - rm1) / 2.;
1504 }
1505 }
1506
1507 for (int i = 0; i < nRings + 1; i++) {
1508 std::stringstream ringName1;
1509 ringName1 << "backWall_" << i;
1510 thickR[i] = backWallThick;
1511 if (i == nRings) {
1512 thickR[i] = 2.*backWallThick;
1513 wallR[i] = detGeo.getSupportOuterR() - thickR[i] / 2.;
1514 }
1515 G4Tubs* backTube = new G4Tubs("hapdBackRing", wallR[i] - thickR[i] / 2., wallR[i] + thickR[i] / 2., backWallHeight / 2., 0,
1516 2 * M_PI);
1517 G4LogicalVolume* hapdBackTubeLV = new G4LogicalVolume(backTube, supportMaterial, "backTube");
1518 G4Transform3D transform3 = G4Translate3D(0., 0., detGeo.getSupportThickness() / 2.);
1519 new G4PVPlacement(transform3, hapdBackTubeLV, "backTube", detSupportLV, false, 1);
1520 if (i == 0) continue;
1521
1522 G4Box* backRadial = new G4Box("backRadialBox", (wallR[i] - wallR[i - 1] - thickR[i] / 2. - thickR[i - 1] / 2.) / 2. - 1.,
1523 backWallThick / 2., backWallHeight / 2.);
1524 hapdBackRadialWallLV.push_back(new G4LogicalVolume(backRadial, supportMaterial, ringName1.str().c_str()));
1525 }
1526
1527 G4SubtractionSolid* substraction = NULL;
1528 unsigned nSlots = detGeo.getNSlots();
1529
1530 if (nSlots > detectorGeo.getFEBCoolingGeometry().getFebcoolingv2GeometryID().size()) {
1531 B2WARNING("GeoARICHCreator: No FEB colling body geometry available so they will not be placed (ARICHGeometryConfig with ClasDef>4 is needed).");
1532 return detSupportLV;
1533 }
1534
1535 // drill holes in support plate
1536 // add FEB cooling bodies
1537 for (unsigned iSlot = 1; iSlot < nSlots + 1; iSlot++) {
1538 unsigned iRing = detGeo.getSlotRing(iSlot);
1539 double r = (wallR[iRing] + wallR[iRing - 1]) / 2. - (thickR[iRing] - thickR[iRing - 1]) / 2.;
1540
1541 double phi = detGeo.getSlotPhi(iSlot);
1542 G4ThreeVector trans(r * cos(phi), r * sin(phi), 0);
1543 G4RotationMatrix Ra;
1544 Ra.rotateZ(phi);
1545
1546 new G4PVPlacement(G4Transform3D(Ra, trans), holeLV, "hole", hapdSupportPlateLV, false, iSlot);
1547 if (substraction) substraction = new G4SubtractionSolid("Box+CylinderMoved", substraction, hole, G4Transform3D(Ra, trans));
1548 else substraction = new G4SubtractionSolid("Box+CylinderMoved", supportPlate, hole, G4Transform3D(Ra, trans));
1549
1550 phi = phi + detGeo.getRingDPhi(iRing) / 2.;
1551 G4ThreeVector transBack(r * cos(phi), r * sin(phi), detGeo.getSupportThickness() / 2.);
1552 G4RotationMatrix RaBack;
1553 RaBack.rotateZ(phi);
1554 new G4PVPlacement(G4Transform3D(RaBack, transBack), hapdBackRadialWallLV[iRing - 1], "hapdBack", detSupportLV, false, iSlot);
1555
1556 // add FEB cooling bodies
1557 G4ThreeVector febCoolingTa;
1558 G4Transform3D febCoolingTr;
1559 febCoolingTa.setX(r * cos(detGeo.getSlotPhi(iSlot)));
1560 febCoolingTa.setY(r * sin(detGeo.getSlotPhi(iSlot)));
1561
1562 double supportTube_envelope_dZ = (detGeo.getSupportThickness() + detGeo.getSupportBackWallHeight());
1563 double febCooling_envelope_dZ = (detectorGeo.getFEBCoolingGeometry().getBigSquareThickness() +
1564 detectorGeo.getFEBCoolingGeometry().getRectangleThickness());
1565 double febCooling_envelope_Z0 = -supportTube_envelope_dZ / 2.0 + febCooling_envelope_dZ / 2.0 + detGeo.getSupportThickness();
1566 febCoolingTa.setZ(febCooling_envelope_Z0);
1567
1568 int febcoolingv2GeometryID = detectorGeo.getFEBCoolingGeometry().getFebcoolingv2GeometryID().at(iSlot - 1);
1569
1570 if (febcoolingv2GeometryID == 2) Ra.rotateZ(90.0 * deg);
1571
1572 febCoolingTr = G4Transform3D(Ra, febCoolingTa);
1573
1574 if (febcoolingv2GeometryID != 0) {
1575 G4LogicalVolume* febCoolingLV = buildFEBCoolingBody(detectorGeo.getFEBCoolingGeometry());
1576
1577 new G4PVPlacement(febCoolingTr, //Transformation
1578 febCoolingLV, //its logical volume
1579 "febCoolingLV", //its name
1580 detSupportLV, //its mother volume
1581 false, //no boolean operation
1582 iSlot); //copy number
1583 }
1584 }
1585
1586 // G4LogicalVolume* hapdSupportPlateLV = new G4LogicalVolume(substraction, supportMaterial, "hapdSupport");
1587
1588 G4Transform3D transform3 = G4Translate3D(0., 0., - backWallHeight / 2.);
1589 new G4PVPlacement(transform3, hapdSupportPlateLV, "supportPlate", detSupportLV, false, 1);
1590
1591 // place electronics side neutron shield - for now hardcoded here, pending for more proper implementation!
1592 G4Box* shieldBox1 = new G4Box("shieldBox1", 20. / 2., 75. / 2., backWallHeight / 2.);
1593 G4Box* shieldBox2 = new G4Box("shieldBox2", 55. / 2., 40. / 2., backWallHeight / 2.);
1594 G4LogicalVolume* shield1 = new G4LogicalVolume(shieldBox1, Materials::get("BoratedPoly"), "ARICH.FWDShield1");
1595 G4LogicalVolume* shield2 = new G4LogicalVolume(shieldBox2, Materials::get("BoratedPoly"), "ARICH.FWDShield2");
1596 double dphi = 2 * M_PI / 36.;
1597 double r1 = wallR[0] - 15.;
1598 double r2 = wallR[0] - 15. - 20. / 2. - 55. / 2.;
1599 for (int i = 0; i < 36; i++) {
1600 double phi = (i + 0.5) * dphi;
1601 G4RotationMatrix rot;
1602 rot.rotateZ(phi);
1603 G4ThreeVector trans(r1 * cos(phi), r1 * sin(phi), detGeo.getSupportThickness() / 2.);
1604 G4ThreeVector trans1(r2 * cos(phi), r2 * sin(phi), detGeo.getSupportThickness() / 2.);
1605 new G4PVPlacement(G4Transform3D(rot, trans), shield1, "ARICH.FWDShield1", detSupportLV, false, i);
1606 new G4PVPlacement(G4Transform3D(rot, trans1), shield2, "ARICH.FWDShield2", detSupportLV, false, i);
1607 }
1608
1609 return detSupportLV;
1610 }
Belle2::arich::GeoARICHCreator::buildFEBCoolingBody
G4LogicalVolume * buildFEBCoolingBody(const ARICHGeoFEBCooling &coolingv2Geo)
build FEB cooling bodies (cooling system update after phase 2)
Definition: GeoARICHCreator.cc:1186

◆ buildFEBCoolingBody()

G4LogicalVolume * buildFEBCoolingBody ( const ARICHGeoFEBCooling &  coolingv2Geo)
private

build FEB cooling bodies (cooling system update after phase 2)

Definition at line 1186 of file GeoARICHCreator.cc.

1187 {
1188
1189 //FEB aluminum cooling envelope for single object
1190 double feb_alcooling_singleObjectEnvelope_sizeX = (2 * coolingv2Geo.getSmallSquareSize() + coolingv2Geo.getBigSquareSize() + 2.0) *
1191 mm;
1192 double feb_alcooling_singleObjectEnvelope_sizeY = feb_alcooling_singleObjectEnvelope_sizeX * mm;
1193 double feb_alcooling_singleObjectEnvelope_sizeZ = (coolingv2Geo.getSmallSquareThickness() + coolingv2Geo.getRectangleThickness()) *
1194 mm;
1195
1196 double feb_alcooling_box1_sizeX = coolingv2Geo.getSmallSquareSize() * mm;
1197 double feb_alcooling_box1_sizeY = feb_alcooling_box1_sizeX;
1198 double feb_alcooling_box1_sizeZ = coolingv2Geo.getSmallSquareThickness() * mm;
1199
1200 double feb_alcooling_box2_sizeX = coolingv2Geo.getBigSquareSize() * mm;
1201 double feb_alcooling_box2_sizeY = feb_alcooling_box2_sizeX;
1202 double feb_alcooling_box2_sizeZ = coolingv2Geo.getBigSquareThickness() * mm;
1203
1204 double feb_alcooling_box3_sizeX = coolingv2Geo.getRectangleW() * mm;
1205 double feb_alcooling_box3_sizeY = coolingv2Geo.getRectangleL() * mm;
1206 double feb_alcooling_box3_sizeZ = coolingv2Geo.getRectangleThickness() * mm;
1207
1208 double feb_alcooling_box1_X0 = feb_alcooling_box2_sizeX / 2.0 + feb_alcooling_box1_sizeX / 2.0;
1209 double feb_alcooling_box1_Y0 = feb_alcooling_box2_sizeY / 2.0 + feb_alcooling_box1_sizeY / 2.0;
1210 double feb_alcooling_box1_Z0 = 0.0 * mm;
1211
1212 //double feb_alcooling_box2_X0 = 0.0*mm;
1213 //double feb_alcooling_box2_Y0 = 0.0*mm;
1214 //double feb_alcooling_box2_Z0 = 0.0*mm;
1215
1216 double feb_alcooling_box3_X0 = coolingv2Geo.getRectangleDistanceFromCenter() / sqrt(2.0) * mm;
1217 double feb_alcooling_box3_Y0 = feb_alcooling_box3_X0;
1218 double feb_alcooling_box3_Z0 = feb_alcooling_box1_sizeZ / 2.0 + feb_alcooling_box3_sizeZ / 2.0;
1219 double feb_alcooling_box3_angle = 45.0 * deg;
1220
1221 G4RotationMatrix Ra;
1222 G4ThreeVector Ta;
1223 G4Transform3D Tr;
1224
1225 //
1226 // Define single FEB aluminum cooling envelope
1227 //
1228 G4VSolid* feb_alcoolingEnvelope_solid = new G4Box("feb_alcoolingEnvelope_solid",
1229 feb_alcooling_singleObjectEnvelope_sizeX / 2.0,
1230 feb_alcooling_singleObjectEnvelope_sizeY / 2.0,
1231 feb_alcooling_singleObjectEnvelope_sizeZ / 2.0);
1232 G4LogicalVolume* feb_alcoolingEnvelope_logical = new G4LogicalVolume(feb_alcoolingEnvelope_solid, Materials::get("Air"),
1233 "feb_alcoolingEnvelope_logical");
1234
1235 G4VSolid* feb_alcooling_box1_solid = new G4Box("feb_alcooling_box1_solid", feb_alcooling_box1_sizeX / 2.0,
1236 feb_alcooling_box1_sizeY / 2.0, feb_alcooling_box1_sizeZ / 2.0);
1237 G4VSolid* feb_alcooling_box2_solid = new G4Box("feb_alcooling_box2_solid", feb_alcooling_box2_sizeX / 2.0,
1238 feb_alcooling_box2_sizeY / 2.0, feb_alcooling_box2_sizeZ / 2.0);
1239 G4VSolid* feb_alcooling_box3_solid = new G4Box("feb_alcooling_box3_solid", feb_alcooling_box3_sizeX / 2.0,
1240 feb_alcooling_box3_sizeY / 2.0, feb_alcooling_box3_sizeZ / 2.0);
1241
1242 //
1243 //Box 1 A
1244 //
1245 Ta.setX(feb_alcooling_box1_X0);
1246 Ta.setY(feb_alcooling_box1_Y0);
1247 Ta.setZ(feb_alcooling_box1_Z0);
1248 Tr = G4Transform3D(Ra, Ta);
1249 G4UnionSolid* feb_alcooling_assembly01_solid = new G4UnionSolid("feb_alcooling_assembly01_solid", feb_alcooling_box2_solid,
1250 feb_alcooling_box1_solid, Tr);
1251 //
1252 //Box 1 B
1253 //
1254 Ta.setX(-feb_alcooling_box1_X0);
1255 Ta.setY(-feb_alcooling_box1_Y0);
1256 Ta.setZ(feb_alcooling_box1_Z0);
1257 Tr = G4Transform3D(Ra, Ta);
1258 G4UnionSolid* feb_alcooling_assembly02_solid = new G4UnionSolid("feb_alcooling_assembly02_solid", feb_alcooling_assembly01_solid,
1259 feb_alcooling_box1_solid, Tr);
1260 //
1261 //Box 3 A
1262 //
1263 Ta.setX(feb_alcooling_box3_X0);
1264 Ta.setY(feb_alcooling_box3_Y0);
1265 Ta.setZ(feb_alcooling_box3_Z0);
1266 Ra.rotateZ(-feb_alcooling_box3_angle);
1267 Tr = G4Transform3D(Ra, Ta);
1268 G4UnionSolid* feb_alcooling_assembly03_solid = new G4UnionSolid("feb_alcooling_assembly03_solid", feb_alcooling_assembly02_solid,
1269 feb_alcooling_box3_solid, Tr);
1270 Ra.rotateZ(feb_alcooling_box3_angle);
1271 //
1272 //Box 3 B
1273 //
1274 Ta.setX(-feb_alcooling_box3_X0);
1275 Ta.setY(-feb_alcooling_box3_Y0);
1276 Ta.setZ(feb_alcooling_box3_Z0);
1277 Ra.rotateZ(-feb_alcooling_box3_angle);
1278 Tr = G4Transform3D(Ra, Ta);
1279 G4UnionSolid* feb_alcooling_assembly_solid = new G4UnionSolid("feb_alcooling_assembly_solid", feb_alcooling_assembly03_solid,
1280 feb_alcooling_box3_solid, Tr);
1281 Ra.rotateZ(feb_alcooling_box3_angle);
1282
1283 G4LogicalVolume* feb_alcooling_assembly_logical = new G4LogicalVolume(feb_alcooling_assembly_solid, Materials::get("Al"),
1284 "feb_alcooling_assembly_logical");
1285 Ta.setX(0.0);
1286 Ta.setY(0.0);
1287 Ta.setZ(-feb_alcooling_box3_sizeZ / 2.0);
1288
1289 Tr = G4Transform3D(Ra, Ta);
1290 new G4PVPlacement(Tr, //Transformation
1291 feb_alcooling_assembly_logical, //its logical volume
1292 "feb_alcooling_assembly", //its name
1293 feb_alcoolingEnvelope_logical, //its mother volume
1294 false, //no boolean operation
1295 0); //copy number
1296
1297 return feb_alcoolingEnvelope_logical;
1298 }
Belle2::sqrt
double sqrt(double a)
sqrt for double
Definition: beamHelpers.h:28

◆ buildHAPD()

G4LogicalVolume * buildHAPD ( const ARICHGeoHAPD &  hapdPar)
private

build the HAPD modules

Definition at line 851 of file GeoARICHCreator.cc.

852 {
853
854 // get module materials
855 string wallMat = hapdGeo.getWallMaterial();
856 string winMat = hapdGeo.getWinMaterial();
857 string apdMat = hapdGeo.getAPDMaterial();
858 string fillMat = hapdGeo.getFillMaterial();
859 string febMat = hapdGeo.getFEBMaterial();
860 G4Material* wallMaterial = Materials::get(wallMat);
861 G4Material* windowMaterial = Materials::get(winMat);
862 G4Material* apdMaterial = Materials::get(apdMat);
863 G4Material* fillMaterial = Materials::get(fillMat);
864 G4Material* febMaterial = Materials::get(febMat);
865 G4Material* moduleFill = Materials::get("ARICH_Air");
866
867 // check that module window material has specified refractive index
868 double wref = getAvgRINDEX(windowMaterial);
869 if (!wref) B2WARNING("Material '" << winMat <<
870 "', required for ARICH photon detector window as no specified refractive index. Continuing, but no photons in ARICH will be detected.");
871
872 // get module dimensions
873 const double hapdSizeX = hapdGeo.getSizeX();
874 const double hapdSizeY = hapdGeo.getSizeY();
875 const double hapdSizeZ = hapdGeo.getSizeZ();
876 const double wallThick = hapdGeo.getWallThickness();
877 const double winThick = hapdGeo.getWinThickness();
878 const double apdSizeX = hapdGeo.getAPDSizeX();
879 const double apdSizeY = hapdGeo.getAPDSizeY();
880 const double apdSizeZ = hapdGeo.getAPDSizeZ();
881 const double botThick = wallThick;
882 const double modHeight = hapdGeo.getModuleSizeZ();
883
884 // module master volume
885 G4Box* moduleBox = new G4Box("moduleBox", hapdSizeX / 2., hapdSizeY / 2., modHeight / 2.);
886 G4LogicalVolume* lmoduleBox = new G4LogicalVolume(moduleBox, moduleFill, "ARICH.HAPDModule");
887
888 // build HAPD box
889 G4Box* hapdBox = new G4Box("hapdBox", hapdSizeX / 2., hapdSizeY / 2., hapdSizeZ / 2.);
890 G4LogicalVolume* lhapdBox = new G4LogicalVolume(hapdBox, fillMaterial, "ARICH.HAPD");
891
892 // build HAPD walls
893 G4Box* tempBox2 = new G4Box("tempBox2", hapdSizeX / 2. - wallThick, hapdSizeY / 2. - wallThick,
894 hapdSizeZ / 2. + 0.1); // Dont't care about "+0.1", needs to be there.
895 G4SubtractionSolid* moduleWall = new G4SubtractionSolid("Box-tempBox", hapdBox, tempBox2);
896 G4LogicalVolume* lmoduleWall = new G4LogicalVolume(moduleWall, wallMaterial, "ARICH.HAPDWall");
897 setColor(*lmoduleWall, "rgb(1.0,0.0,0.0,1.0)");
898 new G4PVPlacement(G4Transform3D(), lmoduleWall, "ARICH.HAPDWall", lhapdBox, false, 1);
899
900 // build HAPD window
901 G4Box* winBox = new G4Box("winBox", hapdSizeX / 2. - wallThick, hapdSizeY / 2. - wallThick, winThick / 2.);
902 G4LogicalVolume* lmoduleWin = new G4LogicalVolume(winBox, windowMaterial, "ARICH.HAPDWindow");
903 setColor(*lmoduleWin, "rgb(0.7,0.7,0.7,1.0)");
904 lmoduleWin->SetSensitiveDetector(m_sensitive);
905 G4Transform3D transform = G4Translate3D(0., 0., (-hapdSizeZ + winThick) / 2.);
906 new G4PVPlacement(transform, lmoduleWin, "ARICH.HAPDWindow", lhapdBox, false, 1);
907
908 // build module bottom
909 G4Box* botBox = new G4Box("botBox", hapdSizeX / 2. - wallThick, hapdSizeY / 2. - wallThick, botThick / 2.);
910 G4LogicalVolume* lmoduleBot = new G4LogicalVolume(botBox, wallMaterial, "ARICH.HAPDBottom");
911 setColor(*lmoduleBot, "rgb(0.0,1.0,0.0,1.0)");
912 G4Transform3D transform1 = G4Translate3D(0., 0., (hapdSizeZ - botThick) / 2.);
913 new G4PVPlacement(transform1, lmoduleBot, "ARICH.HAPDBottom", lhapdBox, false, 1);
914
915 // build apd
916 G4Box* apdBox = new G4Box("apdBox", apdSizeX / 2., apdSizeY / 2., apdSizeZ / 2.);
917 G4LogicalVolume* lApd = new G4LogicalVolume(apdBox, apdMaterial, "ARICH.HAPDApd");
918 if (m_isBeamBkgStudy) lApd->SetSensitiveDetector(new BkgSensitiveDetector("ARICH", 1));
919
920 // add APD surface optical properties
921 Materials& materials = Materials::getInstance();
922
923 G4OpticalSurface* optSurf = materials.createOpticalSurface(hapdGeo.getAPDSurface());
924
925 new G4LogicalSkinSurface("apdSurface", lApd, optSurf);
926 G4Transform3D transform2 = G4Translate3D(0., 0., (hapdSizeZ - apdSizeZ) / 2. - botThick);
927 new G4PVPlacement(transform2, lApd, "ARICH.HAPDApd", lhapdBox, false, 1);
928
929 // build FEB
930 double febSizeX = hapdGeo.getFEBSizeX();
931 double febSizeY = hapdGeo.getFEBSizeY();
932 double febSizeZ = hapdGeo.getFEBSizeZ();
933 G4Box* febBox = new G4Box("febBox", febSizeX / 2., febSizeY / 2., febSizeZ / 2.);
934 G4LogicalVolume* lfeb = new G4LogicalVolume(febBox, febMaterial, "ARICH.HAPDFeb");
935 if (m_isBeamBkgStudy) lfeb->SetSensitiveDetector(new BkgSensitiveDetector("ARICH"));
936 setColor(*lfeb, "rgb(0.0,0.6,0.0,1.0)");
937 G4Transform3D transform3 = G4Translate3D(0., 0., (modHeight - febSizeZ) / 2.);
938 new G4PVPlacement(transform3, lfeb, "ARICH.HAPDFeb", lmoduleBox, false, 1);
939 G4Transform3D transform4 = G4Translate3D(0., 0., - (modHeight - hapdSizeZ) / 2.);
940 new G4PVPlacement(transform4, lhapdBox, "ARICH.HAPD", lmoduleBox, false, 1);
941
942 return lmoduleBox;
943
944 }
Belle2::arich::GeoARICHCreator::getAvgRINDEX
double getAvgRINDEX(G4Material *material)
get refractive index of the material
Definition: GeoARICHCreator.cc:1639
Belle2::geometry::Materials::getInstance
static Materials & getInstance()
Get a reference to the singleton instance.
Definition: Materials.cc:85
Belle2::geometry::setColor
void setColor(G4LogicalVolume &volume, const std::string &color)
Set the color of a logical volume.
Definition: utilities.cc:100

◆ buildMerger()

G4LogicalVolume * buildMerger ( const ARICHGeoMerger &  mergerGeo)
private

build the merger PCB logical volume

Definition at line 975 of file GeoARICHCreator.cc.

976 {
977
978 // This is a screw hole on the merger board.
979 // This high precision of the geometry description is needed
980 // only for the correct placement of the merger cooling bodies.
981 // Volume to subtract (screw hole on the merger board)
982 double screwholeR = mergerGeo.getMergerPCBscrewholeR() * mm;
983 double screwholedY = mergerGeo.getMergerPCBscrewholePosdY() * mm;
984 double screwholedX1 = mergerGeo.getMergerPCBscrewholePosdX1() * mm;
985 double screwholedX2 = mergerGeo.getMergerPCBscrewholePosdX2() * mm;
986
987 G4VSolid* screwHoleTubeSubtracted_solid = new G4Tubs("screwHoleTubeSubtracted_solid",
988 0.0,
989 screwholeR,
990 mergerGeo.getThickness() * mm / 2.0,
991 0, 360.0 * deg);
992
993 // Volume to add (merger box)
994 G4Box* merger_solid = new G4Box("merger_solid",
995 mergerGeo.getSizeW() * mm / 2.0,
996 mergerGeo.getSizeL() * mm / 2.0,
997 mergerGeo.getThickness() * mm / 2.0);
998
999 G4RotationMatrix Ra_sub;
1000 G4ThreeVector Ta_sub;
1001 G4Transform3D Tr_sub;
1002 Ta_sub.setX(-mergerGeo.getSizeW() * mm / 2.0 + screwholedX1);
1003 Ta_sub.setY(mergerGeo.getSizeL() * mm / 2.0 - screwholedY);
1004 Ta_sub.setZ(0.0);
1005 Tr_sub = G4Transform3D(Ra_sub, Ta_sub);
1006 G4SubtractionSolid* substraction_solid = new G4SubtractionSolid("substraction_solid", merger_solid, screwHoleTubeSubtracted_solid,
1007 Tr_sub);
1008 Ta_sub.setX(mergerGeo.getSizeW() * mm / 2.0 - screwholedX2);
1009 Ta_sub.setY(mergerGeo.getSizeL() * mm / 2.0 - screwholedY);
1010 Ta_sub.setZ(0.0);
1011 Tr_sub = G4Transform3D(Ra_sub, Ta_sub);
1012 substraction_solid = new G4SubtractionSolid("substraction_solid", substraction_solid, screwHoleTubeSubtracted_solid, Tr_sub);
1013 Ta_sub.setX(mergerGeo.getSizeW() * mm / 2.0 - screwholedX2);
1014 Ta_sub.setY(-mergerGeo.getSizeL() * mm / 2.0 + screwholedY);
1015 Ta_sub.setZ(0.0);
1016 Tr_sub = G4Transform3D(Ra_sub, Ta_sub);
1017 substraction_solid = new G4SubtractionSolid("substraction_solid", substraction_solid, screwHoleTubeSubtracted_solid, Tr_sub);
1018 Ta_sub.setX(-mergerGeo.getSizeW() * mm / 2.0 + screwholedX1);
1019 Ta_sub.setY(-mergerGeo.getSizeL() * mm / 2.0 + screwholedY);
1020 Ta_sub.setZ(0.0);
1021 Tr_sub = G4Transform3D(Ra_sub, Ta_sub);
1022 substraction_solid = new G4SubtractionSolid("substraction_solid", substraction_solid, screwHoleTubeSubtracted_solid, Tr_sub);
1023
1024 return new G4LogicalVolume(substraction_solid, Materials::get(mergerGeo.getMergerPCBMaterialName()), "ARICH.mergerPCB");
1025 }

◆ buildMergerCooling()

G4LogicalVolume * buildMergerCooling ( unsigned  iType)
private

build merger cooling bodies (cooling system update after phase 2)

Definition at line 1028 of file GeoARICHCreator.cc.

1029 {
1030
1031 if (!m_mergerCooling) {
1032 B2WARNING("ARICH geometry: no data available for merger " << iType << " cooling body geometry. Cooling body will not be placed.");
1033 return NULL;
1034 }
1035
1036 std::stringstream shpName;
1037 shpName << "TessellatedSolid_" << + iType;
1038
1039 G4TessellatedSolid* volume_solid = new G4TessellatedSolid(shpName.str().c_str());
1040
1041 G4ThreeVector point_1;
1042 G4ThreeVector point_2;
1043 G4ThreeVector point_3;
1044
1045 tessellatedSolidStr mergerCoolingStr = m_mergerCooling->getMergerCoolingBodiesInfo(iType);
1046
1047 if (mergerCoolingStr.nCells == 0) {
1048 B2WARNING("ARICH geometry: no data available for merger " << iType << " cooling body geometry. Cooling body will not be placed.");
1049 return NULL;
1050 }
1051
1052 for (unsigned int i = 0; i < mergerCoolingStr.nCells; i++) {
1053 //
1054 point_1.setX(mergerCoolingStr.posV1[0][i]);
1055 point_1.setY(mergerCoolingStr.posV1[1][i]);
1056 point_1.setZ(mergerCoolingStr.posV1[2][i]);
1057 //
1058 point_2.setX(mergerCoolingStr.posV2[0][i]);
1059 point_2.setY(mergerCoolingStr.posV2[1][i]);
1060 point_2.setZ(mergerCoolingStr.posV2[2][i]);
1061 //
1062 point_3.setX(mergerCoolingStr.posV3[0][i]);
1063 point_3.setY(mergerCoolingStr.posV3[1][i]);
1064 point_3.setZ(mergerCoolingStr.posV3[2][i]);
1065 //
1066 G4TriangularFacet* facet = new G4TriangularFacet(point_1, point_2, point_3, ABSOLUTE);
1067 volume_solid->AddFacet((G4VFacet*) facet);
1068 delete facet;
1069 }
1070
1071 volume_solid->SetSolidClosed(true);
1072 std::stringstream volName;
1073 volName << "ARICH.mergerCooling_" << + iType;
1074 G4LogicalVolume* volume_logical = new G4LogicalVolume(volume_solid,
1075 Materials::get(m_mergerCooling->getMergerCoolingBodiesMaterialName()), volName.str().c_str());
1076
1077 setColor(*volume_logical, "rgb(0.6,0.0,0.2,1.0)"); //From the top (farther from IP, downstream)
1078
1079 return volume_logical;
1080 }
Belle2::arich::GeoARICHCreator::m_mergerCooling
OptionalDBObjPtr< ARICHGeoMergerCooling > m_mergerCooling
merger cooling bodies geometry from the DB
Definition: GeoARICHCreator.h:175

◆ buildMergerEnvelope()

G4LogicalVolume * buildMergerEnvelope ( const ARICHGeoMerger &  mergerGeo,
int  type 
)
private

build single merger and merger cooling body envelope logical volume

Definition at line 1082 of file GeoARICHCreator.cc.

1083 {
1084 // Volume to add single merger and merger cooling body envelope box
1085 G4Box* singlemergerenvelope_solid = new G4Box("singlemergerenvelope_solid",
1086 mergerGeo.getSingleMergerEnvelopeSizeW() * mm / 2.0,
1087 mergerGeo.getSingleMergerEnvelopeSizeL() * mm / 2.0,
1088 mergerGeo.getSingleMergerEnvelopeThickness() * mm / 2.0);
1089 std::stringstream volName;
1090 volName << "ARICH.singleMergerEnvelope_" << + iType;
1091 return new G4LogicalVolume(singlemergerenvelope_solid, Materials::get("ARICH_Air"), volName.str().c_str());
1092 }

◆ buildMergerPCBEnvelopePlane()

G4LogicalVolume * buildMergerPCBEnvelopePlane ( const ARICHGeometryConfig &  detectorGeo)
private

build merger PCB assembly envelope plane

Definition at line 1094 of file GeoARICHCreator.cc.

1095 {
1096
1097 const ARICHGeoMerger& mergerGeo = detectorGeo.getMergerGeometry();
1098
1099 if (mergerGeo.getSingleMergerEnvelopeSizeW() < 1e-9) {
1100 B2WARNING("GeoARICHCreator: Merger and merger cooling geometry will not be build as it is not availible in geometry configuration (ARICHGeometryConfig with ClasDef>4 is needed).");
1101 return NULL;
1102 }
1103
1104 G4Tubs* envelope_solid = new G4Tubs("envelope_solid", mergerGeo.getEnvelopeInnerRadius() * mm,
1105 mergerGeo.getEnvelopeOuterRadius() * mm, mergerGeo.getEnvelopeThickness() * mm / 2.0, 0.0, 2.0 * M_PI);
1106
1107 G4LogicalVolume* envelope_logical = new G4LogicalVolume(envelope_solid, Materials::get("ARICH_Air"), "ARICH.mergerEnvelope");
1108
1109
1110 G4LogicalVolume* merger_logical = buildMerger(mergerGeo);
1111 G4LogicalVolume* mergerCooling_logical[12] = {NULL};
1112 G4LogicalVolume* mergerEnvelope_logical[12] = {NULL};
1113 G4ThreeVector TaPCB(mergerGeo.getSingleMergeEnvelopePosition().X() * mm, mergerGeo.getSingleMergeEnvelopePosition().Y() * mm,
1114 mergerGeo.getSingleMergeEnvelopePosition().Z() * mm);
1115 G4RotationMatrix RaPCB;
1116 G4ThreeVector TaMergerCooling(mergerGeo.getSingleMergeEnvelopePosition().X() * mm,
1117 mergerGeo.getSingleMergeEnvelopePosition().Y() * mm, -mergerGeo.getSingleMergeEnvelopePosition().Z() * mm);
1118 G4RotationMatrix RaMergerCooling;
1119 RaMergerCooling.rotateY(180 * deg);
1120 RaMergerCooling.rotateZ(-90 * deg);
1121
1122 // build 12 different merger+cooling body volumes
1123 for (int iType = 1; iType < 13; iType++) {
1124 mergerCooling_logical[iType - 1] = buildMergerCooling(iType);
1125 mergerEnvelope_logical[iType - 1 ] = buildMergerEnvelope(mergerGeo, iType); //Single merger and merger cooling body envelope box
1126 setColor(*mergerEnvelope_logical[iType - 1], "rgb(0.0,0.0,1.0,1.0)");
1127
1128 new G4PVPlacement(G4Transform3D(RaPCB, TaPCB), //Transformation
1129 merger_logical, //its logical volume
1130 "ARICH.mergerPCB", //its name
1131 mergerEnvelope_logical[iType - 1], //its mother volume
1132 false, //no boolean operation
1133 iType); //copy number
1134
1135 if (mergerCooling_logical[iType - 1] == NULL) continue;
1136
1137 new G4PVPlacement(G4Transform3D(RaMergerCooling, TaMergerCooling), //Transformation
1138 mergerCooling_logical[iType - 1], //its logical volume
1139 "ARICH.mergerCooling", //its name
1140 mergerEnvelope_logical[iType - 1], //its mother volume
1141 false, //no boolean operation
1142 iType); //copy number
1143 }
1144
1145 // place all 72 merger+cooling body packages
1146 for (unsigned iSlot = 0; iSlot < mergerGeo.getMergerSlotID().size(); iSlot++) {
1147
1148 int type = 1; // if no merger cooling is available...
1149 if (m_mergerCooling) type = (int)m_mergerCooling->getMergerCoolingPositionID().at(iSlot);
1150
1151 //Placement of the single volume envelope
1152 G4ThreeVector Ta(mergerGeo.getMergerPosR().at(iSlot) * mm * cos(mergerGeo.getMergerAngle().at(iSlot) * deg),
1153 mergerGeo.getMergerPosR().at(iSlot) * mm * sin(mergerGeo.getMergerAngle().at(iSlot) * deg),
1154 mergerGeo.getSingleMergerenvelopeDeltaZ().at(iSlot) * mm);
1155 G4RotationMatrix Ra;
1156 Ra.rotateZ(mergerGeo.getMergerAngle().at(iSlot) * deg + mergerGeo.getMergerOrientation().at(iSlot) * deg);
1157 new G4PVPlacement(G4Transform3D(Ra, Ta), //Transformation
1158 mergerEnvelope_logical[type - 1], //its logical volume
1159 "ARICH.singleMergerEnvelope", //its name
1160 envelope_logical, //its mother volume
1161 false, //no boolean operation
1162 iSlot); //copy number
1163 }
1164
1165 return envelope_logical;
1166
1167 }
Belle2::arich::GeoARICHCreator::buildMergerCooling
G4LogicalVolume * buildMergerCooling(unsigned iType)
build merger cooling bodies (cooling system update after phase 2)
Definition: GeoARICHCreator.cc:1028
Belle2::arich::GeoARICHCreator::buildMergerEnvelope
G4LogicalVolume * buildMergerEnvelope(const ARICHGeoMerger &mergerGeo, int type)
build single merger and merger cooling body envelope logical volume
Definition: GeoARICHCreator.cc:1082
Belle2::arich::GeoARICHCreator::buildMerger
G4LogicalVolume * buildMerger(const ARICHGeoMerger &mergerGeo)
build the merger PCB logical volume
Definition: GeoARICHCreator.cc:975

◆ buildMirror()

G4LogicalVolume * buildMirror ( const ARICHGeometryConfig &  detectorGeo)
private

build mirrors

Definition at line 1613 of file GeoARICHCreator.cc.

1614 {
1615
1616 const ARICHGeoMirrors& mirrGeo = detectorGeo.getMirrors();
1617
1618 // read m_config
1619 string mirrMat = mirrGeo.getMaterial();
1620 G4Material* mirrorMaterial = Materials::get(mirrMat);
1621
1622 double mThick = mirrGeo.getPlateThickness();
1623 double mLength = mirrGeo.getPlateLength();
1624 double mWidth = mirrGeo.getPlateWidth();
1625
1626 G4Box* mirrPlate = new G4Box("mirrPlate", mThick / 2., mLength / 2., mWidth / 2.);
1627
1628 G4LogicalVolume* lmirror = new G4LogicalVolume(mirrPlate, mirrorMaterial, "ARICH.mirrorPlate");
1629
1630 Materials& materials = Materials::getInstance();
1631
1632 G4OpticalSurface* optSurf = materials.createOpticalSurface(mirrGeo.getMirrorSurface());
1633 new G4LogicalSkinSurface("mirrorSurface", lmirror, optSurf);
1634
1635 return lmirror;
1636
1637 }

◆ buildSimpleAerogelPlane()

G4LogicalVolume * buildSimpleAerogelPlane ( const ARICHGeometryConfig &  detectorGeo)
private

build simple aerogel plane (for cosmic test)

Definition at line 442 of file GeoARICHCreator.cc.

443 {
444
445 const ARICHGeoAerogelPlane& aeroGeo = detectorGeo.getAerogelPlane();
446
447 const std::vector<double>& params = aeroGeo.getSimpleParams();
448
449 // support plane
450 double rin = aeroGeo.getSupportInnerR();
451 double rout = aeroGeo.getSupportOuterR();
452 double thick = aeroGeo.getSupportThickness();
453 string supportMat = aeroGeo.getSupportMaterial();
454 double wallHeight = aeroGeo.getWallHeight();
455 G4Material* supportMaterial = Materials::get(supportMat);
456 G4Material* gapMaterial = Materials::get("Air"); // Air without refractive index (to kill photons, to mimic black paper around tile)
457
458 // master volume
459 G4Tubs* aerogelTube = new G4Tubs("aerogelTube", rin, rout, (thick + wallHeight) / 2., 0, 2 * M_PI);
460 G4LogicalVolume* aerogelPlaneLV = new G4LogicalVolume(aerogelTube, gapMaterial, "ARICH.AaerogelPlane");
461
462 // support plate
463 G4Tubs* supportTube = new G4Tubs("aeroSupportTube", rin, rout, thick / 2., 0, 2 * M_PI);
464 G4LogicalVolume* supportTubeLV = new G4LogicalVolume(supportTube, supportMaterial, "ARICH.AerogelSupportPlate");
465 //supportTubeLV->SetSensitiveDetector(m_sensitiveAero);
466
467 unsigned nLayer = aeroGeo.getNLayers();
468
469 // loop over layers
470 double zLayer = 0;
471 for (unsigned iLayer = 1; iLayer < nLayer + 1; iLayer++) {
472 double layerThick = aeroGeo.getLayerThickness(iLayer);
473 std::stringstream tileName;
474 tileName << "aerogelTile_" << iLayer;
475
476 G4Box* tileShape = new G4Box(tileName.str(), params[0] * 10. / 2., params[1] * 10. / 2., layerThick / 2.);
477
478 G4Material* aeroMaterial = Materials::get(aeroGeo.getLayerMaterial(iLayer));
479
480 G4LogicalVolume* tileLV = new G4LogicalVolume(tileShape, aeroMaterial, string("ARICH.") + tileName.str());
481
482 G4ThreeVector transTile(params[2] * 10., params[3] * 10., (thick + layerThick - wallHeight) / 2. + zLayer);
483 G4RotationMatrix Ra;
484 Ra.rotateZ(params[4]);
485 new G4PVPlacement(G4Transform3D(Ra, transTile), tileLV, string("ARICH.") + tileName.str(), aerogelPlaneLV, false, iLayer);
486
487 zLayer += layerThick;
488 }
489
490 new G4PVPlacement(G4Translate3D(0., 0., -wallHeight / 2.), supportTubeLV, "ARICH.AerogelSupportPlate", aerogelPlaneLV, false, 1);
491
492 return aerogelPlaneLV;
493 }

◆ create()

virtual void create ( const GearDir &  content,
G4LogicalVolume &  topVolume,
geometry::GeometryTypes  type 
)
inlineoverridevirtual

Creates the ROOT Objects for the ARICH geometry.

Parameters
contentA reference to the content part of the parameter description, which should to be used to create the ROOT objects.
topVolumetop volume
typegeometry type

Implements CreatorBase.

Definition at line 70 of file GeoARICHCreator.h.

71 {
72 m_config = createConfiguration(content);
73
74 // override geometry configuration from the DB
75 DBStore::Instance().addConstantOverride("ARICHGeometryConfig", new ARICHGeometryConfig(m_config));
76
77 createGeometry(topVolume, type);
78 }
Belle2::arich::GeoARICHCreator::createConfiguration
ARICHGeometryConfig createConfiguration(const GearDir &param)
Reads ARICH geometry parameters from the xml files and createst DB class ARICHGeometryConfig.
Definition: GeoARICHCreator.h:45
Belle2::arich::GeoARICHCreator::createGeometry
void createGeometry(G4LogicalVolume &topVolume, geometry::GeometryTypes type)
Create detector geometry.
Definition: GeoARICHCreator.cc:86
Belle2::arich::GeoARICHCreator::m_config
ARICHGeometryConfig m_config
geometry configuration
Definition: GeoARICHCreator.h:163
Belle2::DBStore::Instance
static DBStore & Instance()
Instance of a singleton DBStore.
Definition: DBStore.cc:28
Belle2::DBStore::addConstantOverride
void addConstantOverride(const std::string &name, TObject *obj, bool oneRun=false)
Add constant override payload.
Definition: DBStore.cc:204

◆ createConfiguration()

ARICHGeometryConfig createConfiguration ( const GearDir &  param)
inlineprivate

Reads ARICH geometry parameters from the xml files and createst DB class ARICHGeometryConfig.

Definition at line 45 of file GeoARICHCreator.h.

46 {
47 ARICHGeometryConfig arichGeometryConfig(param);
48 return arichGeometryConfig;
49 }

◆ createFromDB()

virtual void createFromDB ( const std::string &  name,
G4LogicalVolume &  topVolume,
geometry::GeometryTypes  type 
)
inlineoverridevirtual

Create the geometry from the Database.

Reimplemented from CreatorBase.

Definition at line 89 of file GeoARICHCreator.h.

90 {
91 DBObjPtr<ARICHGeometryConfig> dbObj;
92 if (!dbObj) {
93 // Check that we found the object and if not report the problem
94 B2FATAL("No configuration for " << name << " found.");
95 }
96 m_config = *dbObj;
97 createGeometry(topVolume, type);
98 }

◆ createGeometry()

void createGeometry ( G4LogicalVolume &  topVolume,
geometry::GeometryTypes  type 
)
private

Create detector geometry.

Definition at line 86 of file GeoARICHCreator.cc.

87 {
88
89 m_config.useGeantUnits();
90 m_sensitive = new SensitiveDetector();
91 m_sensitiveAero = new SensitiveAero();
92
93 // print geometry configuration
94 // m_config.print();
95
96 //Build envelope
97 G4Tubs* envelopeTube = new G4Tubs("Envelope", m_config.getMasterVolume().getInnerRadius(),
98 m_config.getMasterVolume().getOuterRadius(), m_config.getMasterVolume().getLength() / 2., 0, 2 * M_PI);
99 G4Material* material = Materials::get(m_config.getMasterVolume().getMaterial());
100
101 // check of material and its refractive index
102 if (!material) { B2FATAL("Material ARICH_Air required for ARICH master volume could not be found");}
103 if (!getAvgRINDEX(material))
104 B2WARNING("Material ARICH_Air required by ARICH master volume has no specified refractive index. Continuing, but no photons in ARICH will be propagated.");
105
106 // create and place
107 G4LogicalVolume* masterLV = new G4LogicalVolume(envelopeTube, material, "ARICH.masterVolume");
108 setVisibility(*masterLV, false);
109
110 // Set up region for production cuts
111 G4Region* aRegion = new G4Region("ARICHEnvelope");
112 masterLV->SetRegion(aRegion);
113 aRegion->AddRootLogicalVolume(masterLV);
114
115 G4RotationMatrix rotMaster;
116 double rot_x = m_config.getMasterVolume().getRotationX();
117 double rot_y = m_config.getMasterVolume().getRotationY();
118 double rot_z = m_config.getMasterVolume().getRotationZ();
119 double tr_x = m_config.getMasterVolume().getPosition().X();
120 double tr_y = m_config.getMasterVolume().getPosition().Y();
121 double tr_z = m_config.getMasterVolume().getPosition().Z();
122
123 if (m_config.useGlobalDisplacement()) {
124 rot_x += m_config.getGlobalDisplacement().getAlpha();
125 rot_y += m_config.getGlobalDisplacement().getBeta();
126 rot_z += m_config.getGlobalDisplacement().getGamma();
127 tr_x += m_config.getGlobalDisplacement().getX();
128 tr_y += m_config.getGlobalDisplacement().getY();
129 tr_z += m_config.getGlobalDisplacement().getZ();
130 B2WARNING("ARICH global displacement parameters from DB will be taken into account.");
131 }
132 rotMaster.rotateX(rot_x);
133 rotMaster.rotateY(rot_y);
134 rotMaster.rotateZ(rot_z);
135
136 G4ThreeVector transMaster(tr_x, tr_y, tr_z);
137
138 new G4PVPlacement(G4Transform3D(rotMaster, transMaster), masterLV, "ARICH.MasterVolume", &topVolume, false, 1);
139
140 m_isBeamBkgStudy = m_config.doBeamBackgroundStudy();
141
142 // Z shift for placing volumes in ARICH master volume
143 double zShift = 0;
144
145 // build photon detector logical volume
146 G4LogicalVolume* detPlaneLV = buildDetectorPlane(m_config);
147 G4LogicalVolume* detSupportPlateLV = buildDetectorSupportPlate(m_config);
148
149 // Build merger PCB logical volume
150 G4LogicalVolume* mergerLV = buildMergerPCBEnvelopePlane(m_config);
151
152 // Build the cables envelop with effective material describing cables
153 G4LogicalVolume* cablesLV = buildCables(m_config.getCablesEnvelope());
154
155 // Build cooling system assembly envelope plane
156 //G4LogicalVolume* coolingLV = buildCoolingEnvelopePlane(m_config.getCoolingGeometry());
157
158 // Build aerogel logical volume
159 G4LogicalVolume* aeroPlaneLV;
160 if (!m_config.getAerogelPlane().isSimple()) {
161 aeroPlaneLV = buildAerogelPlane(m_config);
162 } else {
163 B2INFO("GeoARICHCreator: using simple cosmic test geometry.");
164 aeroPlaneLV = buildSimpleAerogelPlane(m_config);
165 }
166
167 G4RotationMatrix rotDetPlane;
168 rotDetPlane.rotateX(m_config.getDetectorPlane().getRotationX());
169 rotDetPlane.rotateY(m_config.getDetectorPlane().getRotationY());
170 rotDetPlane.rotateZ(m_config.getDetectorPlane().getRotationZ());
171
172 //
173 // For the moment rotation of merger PCB board envelope is not foreseen.
174 //
175 G4RotationMatrix rotMergerPlane;
176 rotMergerPlane.rotateX(0.0);
177 rotMergerPlane.rotateY(0.0);
178 rotMergerPlane.rotateZ(0.0);
179
180 //
181 // For the moment rotation of cables envelope is not foreseen.
182 //
183 G4RotationMatrix rotCablesPlane;
184 rotCablesPlane.rotateX(0.0);
185 rotCablesPlane.rotateY(0.0);
186 rotCablesPlane.rotateZ(0.0);
187
188 G4RotationMatrix rotCoolingPlane;
189 rotCoolingPlane.rotateX(0.0);
190 rotCoolingPlane.rotateY(0.0);
191 rotCoolingPlane.rotateZ(0.0);
192
193 G4RotationMatrix rotAeroPlane;
194 rotAeroPlane.rotateX(m_config.getAerogelPlane().getRotationX());
195 rotAeroPlane.rotateY(m_config.getAerogelPlane().getRotationY());
196 rotAeroPlane.rotateZ(m_config.getAerogelPlane().getRotationZ());
197
198 G4ThreeVector transDetPlane(m_config.getDetectorPlane().getPosition().X(), m_config.getDetectorPlane().getPosition().Y(),
199 m_config.getDetectorPlane().getPosition().Z() + zShift);
200
201 G4ThreeVector transDetSupportPlate(m_config.getDetectorPlane().getPosition().X(), m_config.getDetectorPlane().getPosition().Y(),
202 m_config.getDetectorPlane().getSupportZPosition() + zShift);
203
204 G4ThreeVector transMergerPlate(m_config.getMergerGeometry().getEnvelopeCenterPosition().X() * mm,
205 m_config.getMergerGeometry().getEnvelopeCenterPosition().Y() * mm,
206 m_config.getMergerGeometry().getEnvelopeCenterPosition().Z() * mm + zShift);
207
208 G4ThreeVector transCablesPlate(m_config.getCablesEnvelope().getEnvelopeCenterPosition().X(),
209 m_config.getCablesEnvelope().getEnvelopeCenterPosition().Y(),
210 m_config.getCablesEnvelope().getEnvelopeCenterPosition().Z() + zShift);
211
212 G4ThreeVector transCoolingPlate(m_config.getCoolingGeometry().getEnvelopeCenterPosition().X() * mm,
213 m_config.getCoolingGeometry().getEnvelopeCenterPosition().Y() * mm,
214 m_config.getCoolingGeometry().getEnvelopeCenterPosition().Z() * mm + zShift);
215
216 G4ThreeVector transAeroPlane(m_config.getAerogelPlane().getPosition().X(),
217 m_config.getAerogelPlane().getPosition().Y(),
218 m_config.getAerogelPlane().getPosition().Z() + zShift);
219
220
221 new G4PVPlacement(G4Transform3D(rotDetPlane, transDetPlane), detPlaneLV, "ARICH.detPlane", masterLV, false, 1);
222 new G4PVPlacement(G4Transform3D(rotDetPlane, transDetSupportPlate), detSupportPlateLV, "ARICH.detSupportPlane", masterLV, false, 1);
223 if (mergerLV) new G4PVPlacement(G4Transform3D(rotMergerPlane, transMergerPlate), mergerLV, "ARICH.mergerPlane", masterLV, false, 1);
224 new G4PVPlacement(G4Transform3D(rotCablesPlane, transCablesPlate), cablesLV, "ARICH.cablesPlane", masterLV, false, 1);
225 //new G4PVPlacement(G4Transform3D(rotCoolingPlane, transCoolingPlate), coolingLV, "ARICH.coolingPlane", masterLV, false, 1);
226 new G4PVPlacement(G4Transform3D(rotAeroPlane, transAeroPlane), aeroPlaneLV, "ARICH.aeroPlane", masterLV, false, 1);
227
228 /*
229 // build and place cooling test plates
230 G4LogicalVolume* coolingTestPlatesLV = buildCoolingTestPlate(m_config.getCoolingGeometry());
231 double coolingTestPlateAngle = 0.0;
232 double coolingTestPlateR = 0.0;
233 for (unsigned i = 0; i < m_config.getCoolingGeometry().getCoolingTestPlatePosR().size(); i++) {
234 coolingTestPlateAngle = m_config.getCoolingGeometry().getCoolingTestPlatePosPhi().at(i) * deg;
235 coolingTestPlateR = m_config.getCoolingGeometry().getCoolingTestPlatePosR().at(i) * mm;
236 G4RotationMatrix rotCoolingTestPlate;
237 rotCoolingTestPlate.rotateZ(coolingTestPlateAngle);
238 G4ThreeVector transCoolingTestPlate(coolingTestPlateR * cos(coolingTestPlateAngle),
239 coolingTestPlateR * sin(coolingTestPlateAngle),
240 m_config.getCoolingGeometry().getCoolingTestPlatePosZ0().at(i) * mm + zShift);
241 new G4PVPlacement(G4Transform3D(rotCoolingTestPlate, transCoolingTestPlate), coolingTestPlatesLV, "ARICH.coolingTestPlates",
242 masterLV, false, i);
243 }
244 */
245
246 // build and place mirrors
247 G4LogicalVolume* mirrorLV = buildMirror(m_config);
248 int nMirrors = m_config.getMirrors().getNMirrors();
249 int mirStart = m_config.getMirrors().getStartAngle();
250 int mirZPos = m_config.getMirrors().getZPosition();
251 int mirRad = m_config.getMirrors().getRadius();
252
253 double angl = mirStart;
254 double dphi = 2 * M_PI / nMirrors;
255 if (m_config.useMirrorDisplacement()) B2WARNING("ARICH mirrors displacement parameters from DB will be used.");
256 for (int i = 1; i < nMirrors + 1; i++) {
257 double mrot_x = 0;
258 double mrot_y = 0;
259 double mrot_z = angl;
260 double mtr_x = mirRad * cos(angl);
261 double mtr_y = mirRad * sin(angl);
262 double mtr_z = mirZPos + zShift;
263 if (m_config.useMirrorDisplacement()) {
264 const ARICHPositionElement& displ = m_config.getMirrorDisplacement().getDisplacementElement(i);
265 mrot_x += displ.getAlpha();
266 mrot_y += displ.getBeta();
267 mrot_z += displ.getGamma();
268 mtr_x += displ.getX();
269 mtr_y += displ.getY();
270 mtr_z += displ.getZ();
271 }
272 G4RotationMatrix rotMirror;
273 rotMirror.rotateX(mrot_x);
274 rotMirror.rotateY(mrot_y);
275 rotMirror.rotateZ(mrot_z);
276 G4ThreeVector transMirror(mtr_x, mtr_y, mtr_z);
277 new G4PVPlacement(G4Transform3D(rotMirror, transMirror), mirrorLV, "ARICH.mirrorPlate", masterLV, false, i);
278 angl += dphi;
279 }
280
281 // build additional components of support structure
282
283 const ARICHGeoSupport& supportPar = m_config.getSupportStructure();
284 std::vector<G4LogicalVolume*> shieldLV(2);
285 std::vector<double> shieldZ(2);
286 int nTubes = supportPar.getNTubes();
287 for (int i = 0; i < nTubes; i++) {
288 G4Tubs* tube = new G4Tubs(supportPar.getTubeName(i), supportPar.getTubeInnerR(i), supportPar.getTubeOuterR(i),
289 supportPar.getTubeLength(i) / 2., 0, 2.*M_PI);
290 G4Material* tubeMaterial = Materials::get(supportPar.getTubeMaterial(i));
291
292 if (supportPar.getTubeName(i) == "ARICH.NeutronShield1") {
293 shieldLV[0] = new G4LogicalVolume(tube, tubeMaterial, supportPar.getTubeName(i));
294 shieldZ[0] = supportPar.getTubeZPosition(i) + supportPar.getTubeLength(i) / 2.;
295 continue;
296 } else if (supportPar.getTubeName(i) == "ARICH.NeutronShield2") {
297 shieldLV[1] = new G4LogicalVolume(tube, tubeMaterial, supportPar.getTubeName(i));
298 shieldZ[1] = supportPar.getTubeZPosition(i) + supportPar.getTubeLength(i) / 2.;
299 continue;
300 }
301
302 G4LogicalVolume* tubeLV = new G4LogicalVolume(tube, tubeMaterial, supportPar.getTubeName(i));
303
304 new G4PVPlacement(G4Transform3D(G4RotationMatrix(), G4ThreeVector(0, 0,
305 supportPar.getTubeZPosition(i) + supportPar.getTubeLength(i) / 2. + zShift)), tubeLV, supportPar.getTubeName(i), masterLV, false,
306 1);
307 }
308
309 const std::vector<double> wedge1 = supportPar.getWedge(1);
310 const std::vector<double> wedge2 = supportPar.getWedge(2);
311 G4Material* wedge1Material = Materials::get(supportPar.getWedgeMaterial(1));
312 G4Material* wedge2Material = Materials::get(supportPar.getWedgeMaterial(2));
313 G4AssemblyVolume* assemblyWedge1 = new G4AssemblyVolume();
314 G4AssemblyVolume* assemblyWedge2 = new G4AssemblyVolume();
315 makeJoint(wedge1Material, wedge1, assemblyWedge1);
316 makeJoint(wedge2Material, wedge2, assemblyWedge2);
317
318 G4Transform3D Tr;
319 int nWedge = supportPar.getNWedges();
320 for (int i = 0; i < nWedge; i++) {
321 G4RotationMatrix Rx;
322 int wgtype = supportPar.getWedgeType(i);
323 double phi = supportPar.getWedgePhi(i);
324 Rx.rotateZ(phi);
325 double r = supportPar.getWedgeR(i);
326 double z = supportPar.getWedgeZ(i);
327 G4ThreeVector Tb(r * cos(phi), r * sin(phi), z);
328
329 if (shieldLV[0]) {
330 z -= shieldZ[0];
331 Tb.setZ(z);
332 Tr = G4Transform3D(Rx, Tb);
333 if (wgtype == 1) assemblyWedge1->MakeImprint(shieldLV[0], Tr);
334 else if (wgtype == 2) assemblyWedge2->MakeImprint(shieldLV[0], Tr);
335 continue;
336 }
337
338 Tr = G4Transform3D(Rx, Tb);
339 if (wgtype == 1) assemblyWedge1->MakeImprint(masterLV, Tr);
340 else if (wgtype == 2) assemblyWedge2->MakeImprint(masterLV, Tr);
341 else B2ERROR("GeoARICHCreator: invalid support wedge type!");
342 }
343
344 // place neutron shield volumes
345 if (shieldLV[0])
346 new G4PVPlacement(G4Transform3D(G4RotationMatrix(), G4ThreeVector(0, 0, shieldZ[0])), shieldLV[0], "ARICH.NeutronShield1", masterLV,
347 false, 1);
348 if (shieldLV[1])
349 new G4PVPlacement(G4Transform3D(G4RotationMatrix(), G4ThreeVector(0, 0, shieldZ[1])), shieldLV[1], "ARICH.NeutronShield2", masterLV,
350 false, 1);
351
352 // place mirror holders, for now skip
353 /*
354 double mirSupX = 17.;
355 double mirSupY = 14.;
356 double mirSupLen = 131;
357 double mirSupLen1 = 201;
358
359 std::vector<G4TwoVector> polygon;
360 polygon.assign(12, G4TwoVector());
361 polygon[11] = G4TwoVector(-mirSupX / 2., -mirSupY / 2.);
362 polygon[10] = G4TwoVector(-mirSupX / 2., 2.);
363 polygon[9] = G4TwoVector(-mirSupX / 4., 2. - 0.75);
364 polygon[8] = G4TwoVector(-mirSupX / 4., 5. - 0.75);
365 polygon[7] = G4TwoVector(-mirSupX / 2., 5);
366 polygon[6] = G4TwoVector(-mirSupX / 2., mirSupY / 2.);
367 polygon[5] = G4TwoVector(mirSupX / 2., mirSupY / 2.);
368 polygon[4] = G4TwoVector(mirSupX / 2., 6);
369 polygon[3] = G4TwoVector(mirSupX / 4., 6. - 0.75);
370 polygon[2] = G4TwoVector(mirSupX / 4., 2. - 0.75);
371 polygon[1] = G4TwoVector(mirSupX / 2., 2.);
372 polygon[0] = G4TwoVector(mirSupX / 2., -mirSupY / 2.);
373
374 std::vector<G4ExtrudedSolid::ZSection> zsections;
375 zsections.push_back(G4ExtrudedSolid::ZSection(-mirSupLen / 2., G4TwoVector(0, 0), 1));
376 zsections.push_back(G4ExtrudedSolid::ZSection(mirSupLen / 2., G4TwoVector(0, 0), 1));
377
378 G4ExtrudedSolid* shape = new G4ExtrudedSolid("bla", polygon, zsections);
379 G4LogicalVolume* shapeLV = new G4LogicalVolume(shape, wedge1Material, "mirrorsupport");
380
381 G4Box* shape1 = new G4Box("shape1", mirSupX / 2., 2. / 2., mirSupLen1 / 2.);
382 G4LogicalVolume* shape1LV = new G4LogicalVolume(shape1, wedge1Material, "mirrorholder");
383
384 G4AssemblyVolume* mirroHolder = new G4AssemblyVolume();
385 G4RotationMatrix Rh;
386 G4ThreeVector Th(0, 0, 0);
387 Tr = G4Transform3D(Rh, Th);
388 mirroHolder->AddPlacedVolume(shapeLV, Tr);
389
390 Th.setZ(-35.0);
391 Th.setY(-mirSupY / 2. - 1.);
392 Tr = G4Transform3D(Rh, Th);
393 mirroHolder->AddPlacedVolume(shape1LV, Tr);
394
395 double rholder = m_config.getDetectorPlane().getSupportOuterR() - mirSupY / 2.;
396
397 angl = dphi / 2.;
398 for (int i = 1; i < nMirrors + 1; i++) {
399 G4RotationMatrix rotMirror;
400 rotMirror.rotateX(M_PI);
401 rotMirror.rotateZ(-M_PI / 2. + angl);
402 G4ThreeVector transMirror(rholder * cos(angl), rholder * sin(angl), mirZPos + zShift);
403 Tr = G4Transform3D(rotMirror, transMirror);
404 mirroHolder->MakeImprint(masterLV, Tr);
405 angl += dphi;
406 }
407 */
408
409 // temporary for simple cosmic test
410 // if using simple configuration, place scinitilators
411 if (m_config.getAerogelPlane().isSimple()) {
412 int nBoxes = supportPar.getNBoxes();
413 for (int i = 0; i < nBoxes; i++) {
414 ARICHGeoSupport::box box = supportPar.getBox(i);
415 G4Box* scintBox = new G4Box("scintBox", box.size[0] * 10. / 2., box.size[1] * 10. / 2., box.size[2] * 10. / 2.);
416 G4Material* scintMaterial = Materials::get(box.material);
417 G4LogicalVolume* scintLV = new G4LogicalVolume(scintBox, scintMaterial, box.name);
418 scintLV->SetSensitiveDetector(m_sensitiveAero);
419 G4RotationMatrix rotScint;
420 rotScint.rotateX(box.rotation[0]);
421 rotScint.rotateY(box.rotation[1]);
422 rotScint.rotateZ(box.rotation[2]);
423 ROOT::Math::XYZVector transScintTV(box.position[0], box.position[1], box.position[2]);
424 transScintTV = m_config.getMasterVolume().pointToGlobal(transScintTV);
425 B2INFO("GeoARICHCreator: Scintilator " << box.name << " placed at global: " << transScintTV.X() << " " << transScintTV.Y() << " " <<
426 transScintTV.Z());
427 G4ThreeVector transScint(box.position[0] * 10., box.position[1] * 10., box.position[2] * 10.);
428 new G4PVPlacement(G4Transform3D(rotScint, transScint), scintLV, "scintilator", masterLV, false, 1);
429 }
430 }
431
432 m_config.useBasf2Units();
433
434 delete assemblyWedge1;
435 delete assemblyWedge2;
436
437 return;
438
439 }
Belle2::ARICHGeoAerogelPlane::isSimple
bool isSimple() const
Use simple aerogel configuration.
Definition: ARICHGeoAerogelPlane.h:388
Belle2::ARICHGeoAerogelPlane::getRotationY
double getRotationY() const
Get angle of rotation around Y axis.
Definition: ARICHGeoAerogelPlane.h:204
Belle2::ARICHGeoAerogelPlane::getRotationZ
double getRotationZ() const
Get angle of rotation around Z axis.
Definition: ARICHGeoAerogelPlane.h:210
Belle2::ARICHGeoAerogelPlane::getPosition
ROOT::Math::XYZVector getPosition() const
Get position vector of aerogel plane in ARICH local frame.
Definition: ARICHGeoAerogelPlane.h:178
Belle2::ARICHGeoAerogelPlane::getRotationX
double getRotationX() const
Get angle of rotation around X axis.
Definition: ARICHGeoAerogelPlane.h:198
Belle2::ARICHGeoCablesEnvelope::getEnvelopeCenterPosition
ROOT::Math::XYZVector getEnvelopeCenterPosition() const
Returns position vector (ROOT::Math::XYZVector) of cables envelop.
Definition: ARICHGeoCablesEnvelope.h:96
Belle2::ARICHGeoCooling::getEnvelopeCenterPosition
ROOT::Math::XYZVector getEnvelopeCenterPosition() const
Get position vector (ROOT::Math::XYZVector) of cooling system assembly envelope.
Definition: ARICHGeoCooling.h:263
Belle2::ARICHGeoDetectorPlane::getSupportZPosition
double getSupportZPosition() const
Get Z position of support plate (start point in Z).
Definition: ARICHGeoDetectorPlane.h:175
Belle2::ARICHGeoDetectorPlane::getRotationY
double getRotationY() const
Get angle of rotation around Y axis.
Definition: ARICHGeoDetectorPlane.h:145
Belle2::ARICHGeoDetectorPlane::getRotationZ
double getRotationZ() const
Get angle of rotation around Z axis.
Definition: ARICHGeoDetectorPlane.h:151
Belle2::ARICHGeoDetectorPlane::getPosition
ROOT::Math::XYZVector getPosition() const
Get center point.
Definition: ARICHGeoDetectorPlane.h:119
Belle2::ARICHGeoDetectorPlane::getRotationX
double getRotationX() const
Get angle of rotation around X axis.
Definition: ARICHGeoDetectorPlane.h:139
Belle2::ARICHGeoGlobalDisplacement::getGamma
double getGamma() const
Returns rotation angle around z.
Definition: ARICHGeoGlobalDisplacement.h:121
Belle2::ARICHGeoGlobalDisplacement::getX
double getX() const
Returns translation in x.
Definition: ARICHGeoGlobalDisplacement.h:91
Belle2::ARICHGeoGlobalDisplacement::getAlpha
double getAlpha() const
Returns rotation angle around x.
Definition: ARICHGeoGlobalDisplacement.h:109
Belle2::ARICHGeoGlobalDisplacement::getZ
double getZ() const
Returns translation in z.
Definition: ARICHGeoGlobalDisplacement.h:103
Belle2::ARICHGeoGlobalDisplacement::getY
double getY() const
Returns translation in y.
Definition: ARICHGeoGlobalDisplacement.h:97
Belle2::ARICHGeoGlobalDisplacement::getBeta
double getBeta() const
Returns rotation angle around y.
Definition: ARICHGeoGlobalDisplacement.h:115
Belle2::ARICHGeoMasterVolume::pointToGlobal
ROOT::Math::XYZVector pointToGlobal(const ROOT::Math::XYZVector &point) const
Transform local point into global Belle II coordinate system via rotation and translation.
Definition: ARICHGeoMasterVolume.cc:17
Belle2::ARICHGeoMasterVolume::getRotationY
double getRotationY() const
Get angle of rotation around Y axis.
Definition: ARICHGeoMasterVolume.h:114
Belle2::ARICHGeoMasterVolume::getRotationZ
double getRotationZ() const
Get angle of rotation around Z axis.
Definition: ARICHGeoMasterVolume.h:120
Belle2::ARICHGeoMasterVolume::getOuterRadius
double getOuterRadius() const
Get ARICH master volume outer radius.
Definition: ARICHGeoMasterVolume.h:132
Belle2::ARICHGeoMasterVolume::getInnerRadius
double getInnerRadius() const
Get ARICH master volume inner radius.
Definition: ARICHGeoMasterVolume.h:126
Belle2::ARICHGeoMasterVolume::getMaterial
const std::string & getMaterial() const
Get material of ARICH master volume.
Definition: ARICHGeoMasterVolume.h:144
Belle2::ARICHGeoMasterVolume::getPosition
ROOT::Math::XYZVector getPosition() const
Get position of ARICH master volume center point in global Belle II coordinates.
Definition: ARICHGeoMasterVolume.h:88
Belle2::ARICHGeoMasterVolume::getLength
double getLength() const
Get ARICH master volume length.
Definition: ARICHGeoMasterVolume.h:138
Belle2::ARICHGeoMasterVolume::getRotationX
double getRotationX() const
Get angle of rotation around X axis.
Definition: ARICHGeoMasterVolume.h:108
Belle2::ARICHGeoMerger::getEnvelopeCenterPosition
ROOT::Math::XYZVector getEnvelopeCenterPosition() const
Returns position vector (ROOT::Math::XYZVector) of merger PCB assembly envelope.
Definition: ARICHGeoMerger.h:260
Belle2::ARICHGeoMirrorDisplacement::getDisplacementElement
const ARICHPositionElement & getDisplacementElement(int mirrorID) const
Returns displacement parameters for given mirror plate.
Definition: ARICHGeoMirrorDisplacement.h:49
Belle2::ARICHGeoMirrors::getZPosition
double getZPosition() const
Get nominal Z position of mirror plates (center point in ARICH local frame)
Definition: ARICHGeoMirrors.h:96
Belle2::ARICHGeoMirrors::getNMirrors
unsigned getNMirrors() const
Get number of mirror plates.
Definition: ARICHGeoMirrors.h:132
Belle2::ARICHGeoMirrors::getRadius
double getRadius() const
Get nominal radius at which mirror plates are placed (center of plate)
Definition: ARICHGeoMirrors.h:102
Belle2::ARICHGeoMirrors::getStartAngle
double getStartAngle() const
Get phi angle of position of the first mirror plate.
Definition: ARICHGeoMirrors.h:108
Belle2::ARICHGeometryConfig::getAerogelPlane
const ARICHGeoAerogelPlane & getAerogelPlane() const
Get geometry configuration of aerogel plane.
Definition: ARICHGeometryConfig.h:97
Belle2::ARICHGeometryConfig::getMergerGeometry
const ARICHGeoMerger & getMergerGeometry() const
Get Merger PCB geometry parameters.
Definition: ARICHGeometryConfig.h:127
Belle2::ARICHGeometryConfig::useGeantUnits
static void useGeantUnits()
Use Geant4 units when returning geometry parameters.
Definition: ARICHGeometryConfig.h:69
Belle2::ARICHGeometryConfig::getGlobalDisplacement
const ARICHGeoGlobalDisplacement & getGlobalDisplacement() const
Get global displacement parameters.
Definition: ARICHGeometryConfig.h:151
Belle2::ARICHGeometryConfig::useMirrorDisplacement
bool useMirrorDisplacement() const
Get whether mirror displacement is used.
Definition: ARICHGeometryConfig.h:252
Belle2::ARICHGeometryConfig::getMasterVolume
const ARICHGeoMasterVolume & getMasterVolume() const
Get ARICH master volume geometry configuration.
Definition: ARICHGeometryConfig.h:109
Belle2::ARICHGeometryConfig::getCoolingGeometry
const ARICHGeoCooling & getCoolingGeometry() const
Get ARICH cooling system geometry parameters.
Definition: ARICHGeometryConfig.h:139
Belle2::ARICHGeometryConfig::getMirrors
const ARICHGeoMirrors & getMirrors() const
Get mirrors geometry configuration.
Definition: ARICHGeometryConfig.h:103
Belle2::ARICHGeometryConfig::getCablesEnvelope
const ARICHGeoCablesEnvelope & getCablesEnvelope() const
Get ARICH cables envelop geometry parameters.
Definition: ARICHGeometryConfig.h:133
Belle2::ARICHGeometryConfig::useBasf2Units
static void useBasf2Units()
Use basf2 units when returning geometry parameters.
Definition: ARICHGeometryConfig.h:63
Belle2::ARICHGeometryConfig::useGlobalDisplacement
bool useGlobalDisplacement() const
Get whether global displacement is used.
Definition: ARICHGeometryConfig.h:244
Belle2::ARICHGeometryConfig::getDetectorPlane
const ARICHGeoDetectorPlane & getDetectorPlane() const
Get geometry configuration of HAPD plane.
Definition: ARICHGeometryConfig.h:91
Belle2::ARICHGeometryConfig::getMirrorDisplacement
const ARICHGeoMirrorDisplacement & getMirrorDisplacement() const
Get mirror displacement parameters.
Definition: ARICHGeometryConfig.h:157
Belle2::ARICHGeometryConfig::getSupportStructure
const ARICHGeoSupport & getSupportStructure() const
Get ARICH support structure geometry configuration.
Definition: ARICHGeometryConfig.h:115
Belle2::arich::GeoARICHCreator::buildSimpleAerogelPlane
G4LogicalVolume * buildSimpleAerogelPlane(const ARICHGeometryConfig &detectorGeo)
build simple aerogel plane (for cosmic test)
Definition: GeoARICHCreator.cc:442
Belle2::arich::GeoARICHCreator::makeJoint
void makeJoint(G4Material *supportMaterial, const std::vector< double > &pars, G4AssemblyVolume *assemblyWedge)
build joints of the ARICH support structure
Definition: GeoARICHCreator.cc:1649
Belle2::arich::GeoARICHCreator::buildMergerPCBEnvelopePlane
G4LogicalVolume * buildMergerPCBEnvelopePlane(const ARICHGeometryConfig &detectorGeo)
build merger PCB assembly envelope plane
Definition: GeoARICHCreator.cc:1094
Belle2::arich::GeoARICHCreator::buildCables
G4LogicalVolume * buildCables(const ARICHGeoCablesEnvelope &cablesGeo)
build the cables envelop with effective material describing cables
Definition: GeoARICHCreator.cc:1169
Belle2::arich::GeoARICHCreator::buildDetectorSupportPlate
G4LogicalVolume * buildDetectorSupportPlate(const ARICHGeometryConfig &detectorGeo)
build detector support plate
Definition: GeoARICHCreator.cc:1466
Belle2::arich::GeoARICHCreator::buildAerogelPlane
G4LogicalVolume * buildAerogelPlane(const ARICHGeometryConfig &detectorGeo)
build aerogel plane
Definition: GeoARICHCreator.cc:495
Belle2::arich::GeoARICHCreator::buildDetectorPlane
G4LogicalVolume * buildDetectorPlane(const ARICHGeometryConfig &detectorGeo)
build detector plane
Definition: GeoARICHCreator.cc:946
Belle2::arich::GeoARICHCreator::buildMirror
G4LogicalVolume * buildMirror(const ARICHGeometryConfig &detectorGeo)
build mirrors
Definition: GeoARICHCreator.cc:1613
Belle2::ARICHGeometryConfig::doBeamBackgroundStudy
int doBeamBackgroundStudy() const
returns 1 if beam background study (to add additional sensitive modules, detect neutrons,...
Definition: ARICHGeometryConfig.h:289
Belle2::PXD::SensitiveDetector
VXD::SensitiveDetector< PXDSimHit, PXDTrueHit > SensitiveDetector
The PXD Sensitive Detector class.
Definition: SensitiveDetector.h:23
Belle2::geometry::setVisibility
void setVisibility(G4LogicalVolume &volume, bool visible)
Helper function to quickly set the visibility of a given volume.
Definition: utilities.cc:108

◆ createPayloads()

virtual void createPayloads ( const GearDir &  content,
const IntervalOfValidity &  iov 
)
inlineoverridevirtual

creates DB payload for ARICHGeometryConfig class

Reimplemented from CreatorBase.

Definition at line 81 of file GeoARICHCreator.h.

82 {
83 DBImportObjPtr<ARICHGeometryConfig> importObj;
84 importObj.construct(createConfiguration(content));
85 importObj.import(iov);
86 }

◆ getAvgRINDEX()

double getAvgRINDEX ( G4Material *  material)
private

get refractive index of the material

Definition at line 1639 of file GeoARICHCreator.cc.

1640 {
1641 G4MaterialPropertiesTable* mTable = material->GetMaterialPropertiesTable();
1642 if (!mTable) return 0;
1643 G4MaterialPropertyVector* mVector = mTable->GetProperty("RINDEX");
1644 if (!mVector) return 0;
1645 G4bool b;
1646 return mVector->GetValue(2 * Unit::eV / Unit::MeV, b);
1647 }
Belle2::Unit::eV
static const double eV
[electronvolt]
Definition: Unit.h:112
Belle2::Unit::MeV
static const double MeV
[megaelectronvolt]
Definition: Unit.h:114

◆ makeJoint()

void makeJoint ( G4Material *  supportMaterial,
const std::vector< double > &  pars,
G4AssemblyVolume *  assemblyWedge 
)
private

build joints of the ARICH support structure

Definition at line 1649 of file GeoARICHCreator.cc.

1650 {
1651
1652 int size = par.size();
1653 if (size < 4 || size > 8) B2ERROR("GeoARICHCreator::makeJoint: invalid number of joint wedge parameters");
1654 double lenx = par.at(0);
1655 double leny = par.at(1);
1656 double lenz = par.at(2);
1657 double thick = par.at(3);
1658
1659 G4Box* wedgeBox1 = new G4Box("wedgeBox1", thick / 2., lenx / 2., leny / 2.);
1660 G4Box* wedgeBox2 = new G4Box("wedgeBox2", lenz / 2., lenx / 2., thick / 2.);
1661
1662 G4LogicalVolume* wedgeBox1LV = new G4LogicalVolume(wedgeBox1, supportMaterial, "ARICH.supportWedge");
1663 G4LogicalVolume* wedgeBox2LV = new G4LogicalVolume(wedgeBox2, supportMaterial, "ARICH.supportWedge");
1664
1665 G4RotationMatrix Rm;
1666 G4ThreeVector Ta(0, 0, 0);
1667 G4Transform3D Tr;
1668 Tr = G4Transform3D(Rm, Ta);
1669
1670 assemblyWedge->AddPlacedVolume(wedgeBox1LV, Tr);
1671
1672 Ta.setX(lenz / 2. + thick / 2.);
1673 Ta.setZ(leny / 2. - thick / 2.);
1674 Tr = G4Transform3D(Rm, Ta);
1675 assemblyWedge->AddPlacedVolume(wedgeBox2LV, Tr);
1676
1677 if (size == 4) return;
1678 double edge = par.at(4);
1679
1680 G4Box* wedgeBox3 = new G4Box("wedgeBox3", lenz / 2., edge / 2., thick / 2.);
1681 G4LogicalVolume* wedgeBox3LV = new G4LogicalVolume(wedgeBox3, supportMaterial, "ARICH.supportWedge");
1682
1683 Ta.setZ(leny / 2. - thick - thick / 2.);
1684 Tr = G4Transform3D(Rm, Ta);
1685 assemblyWedge->AddPlacedVolume(wedgeBox3LV, Tr);
1686
1687 G4Trap* wedgeBoxTmp = new G4Trap("wedgeBoxTmp", thick, leny - 2 * thick, lenz, edge);
1688 G4LogicalVolume* wedgeBox4LV;
1689 if (size == 8) {
1690 G4Tubs* wedgeBoxTmp1 = new G4Tubs("wedgeBoxTmp1", 0.0, par.at(5), thick, 0, 2.*M_PI);
1691 G4RotationMatrix rotHole;
1692 G4ThreeVector transHole(par.at(6), par.at(7), 0);
1693 G4SubtractionSolid* wedgeBox4 = new G4SubtractionSolid("wedgeBox4", wedgeBoxTmp, wedgeBoxTmp1, G4Transform3D(rotHole, transHole));
1694 wedgeBox4LV = new G4LogicalVolume(wedgeBox4, supportMaterial, "ARICH.supportWedge");
1695 } else wedgeBox4LV = new G4LogicalVolume(wedgeBoxTmp, supportMaterial, "ARICH.supportWedge");
1696
1697 Rm.rotateX(-M_PI / 2.);
1698 Ta.setX(thick / 2. + edge / 4. + lenz / 4.);
1699 Ta.setZ(-thick / 2. - edge / 2.);
1700 Tr = G4Transform3D(Rm, Ta);
1701 assemblyWedge->AddPlacedVolume(wedgeBox4LV, Tr);
1702
1703 }

Member Data Documentation

◆ m_config

ARICHGeometryConfig m_config
private

geometry configuration

Definition at line 163 of file GeoARICHCreator.h.

◆ m_isBeamBkgStudy

int m_isBeamBkgStudy
private

flag the beam background study

Definition at line 172 of file GeoARICHCreator.h.

◆ m_mergerCooling

OptionalDBObjPtr<ARICHGeoMergerCooling> m_mergerCooling
private

merger cooling bodies geometry from the DB

Definition at line 175 of file GeoARICHCreator.h.

◆ m_modInfo

DBObjPtr<ARICHModulesInfo> m_modInfo
private

information on installed modules from the DB

Definition at line 174 of file GeoARICHCreator.h.

◆ m_sensitive

SensitiveDetector* m_sensitive
private

pointer to sensitive detector

Definition at line 166 of file GeoARICHCreator.h.

◆ m_sensitiveAero

SensitiveAero* m_sensitiveAero
private

pointer to sensitive aerogel - used instead of tracking

Definition at line 169 of file GeoARICHCreator.h.

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