BesPip Class Reference

#include <BesPip.hh>

Inheritance diagram for BesPip:

Public Member Functions
	BesPip ()
virtual	~BesPip ()
void	Construct (G4LogicalVolume *logicbes)
void	DefineMaterial ()
Public Member Functions inherited from BesSubdetector
	BesSubdetector ()
virtual	~BesSubdetector ()
G4LogicalVolume *	FindLogicalVolume (const G4String &vn)

Additional Inherited Members
Protected Attributes inherited from BesSubdetector
SAXProcessor	m_sxp
ProcessingConfigurator	m_config

Detailed Description

Definition at line 19 of file BesPip.hh.

Constructor & Destructor Documentation

BesPip()

BesPip::BesPip

(

)

Definition at line 27 of file BesPip.cc.

{
  pipPar = new BesPipParameter();
  pipPar->ReadData();
  for(G4int i=0; i<3; i++)
  {
    goldLayer[i] = pipPar->getGoldLayer(i);
    innerBe[i] = pipPar->getInnerBe(i);
    oilLayer[i] = pipPar->getOilLayer(i);
    outerBe[i] = pipPar->getOuterBe(i);
  }
 
  for(G4int i=0; i<5; i++)
  {
    innerBeSide[i] = pipPar->getInnerBeSide(i);
    innerAl[i] = pipPar->getInnerAl(i);
    AlRing[i] = pipPar->getAlRing(i);
    outerAl[i] = pipPar->getOuterAl(i);
    AgLayer[i] = pipPar->getAgLayer(i);
    CuLayer[i] = pipPar->getCuLayer(i);
    AlCover[i] = pipPar->getAlCover(i);
  }
 
  logicalPip = 0;
  physicalPip = 0;
 
  logicalgoldLayer = 0;
  physicalgoldLayer = 0;
 
  logicalinnerBe = 0;
  physicalinnerBe = 0;
 
  logicaloilLayer = 0;
  physicaloilLayer = 0;
 
  logicalouterBe = 0;
  physicalouterBe = 0;
 
   logicalinnerBeSide = 0;
   physicalinnerBeSide = 0;
 
   logicalinnerAl = 0;
   physicalinnerAl = 0;
 
   logicalAlRing = 0;
   physicalAlRing = 0;
 
   logicalouterAl = 0;
   physicalouterAl = 0;
  
   logicalAgLayer = 0;
   physicalAgLayer = 0;
 
   logicalCuLayer = 0;
   physicalCuLayer = 0;
 
   logicalAlCover = 0;
   physicalAlCover = 0;
 
  Au = 0;
  Ag = 0;
  Oil = 0;
}

~BesPip()

virtual BesPip::~BesPip ( )

inlinevirtual

Definition at line 24 of file BesPip.hh.

{;}

Member Function Documentation

Construct()

void BesPip::Construct ( G4LogicalVolume * logicbes )

virtual

Implements BesSubdetector.

Definition at line 117 of file BesPip.cc.

{
  DefineMaterial();
 
   //G4RotationMatrix* xRot = new G4RotationMatrix;
  //xRot->rotateX(90*deg);
 
  //the logical volume of beam pipe
  G4Tubs* solidPip1 = new G4Tubs("solidPip1",0.,33.7,134,0,360);
  G4Tubs* solidPip2 = new G4Tubs("solidPip2",0.,48,66,0,360);
  G4UnionSolid* solidPip_tmp = new G4UnionSolid("solidPip_tmp",solidPip1,solidPip2,0,G4ThreeVector(0,0,-167));
  G4UnionSolid* solidPip = new G4UnionSolid("solidPip",solidPip_tmp,solidPip2,0,G4ThreeVector(0,0,167));
  logicalPip = new G4LogicalVolume(solidPip, G4Material::GetMaterial("Beam"),"logicalPip");
  physicalPip = new G4PVPlacement(0,G4ThreeVector(0,0,0),logicalPip,"physicalPip",logicalbes,false,0);
 
  //the volume of gold layer
  G4Tubs* solidgoldLayer = new G4Tubs("solidgoldLayer",goldLayer[0],goldLayer[1],goldLayer[2]/2,0,360);
  logicalgoldLayer = new G4LogicalVolume(solidgoldLayer, Au,"logicalgoldLayer");
  physicalgoldLayer = new G4PVPlacement(0,G4ThreeVector(0,0,0),logicalgoldLayer,"physicalgoldLayer",logicalPip,false,0);
 
  //the volume of inner Be pipe
  G4Tubs* solidinnerBe = new G4Tubs("solidinnerBe",innerBe[0],innerBe[1],innerBe[2]/2,0,360);
  logicalinnerBe = new G4LogicalVolume(solidinnerBe, G4Material::GetMaterial("Beryllium"),"logicalinnerBe");
  physicalinnerBe = new G4PVPlacement(0,G4ThreeVector(0,0,0),logicalinnerBe,"physicalinnerBe",logicalPip,false,0);
 
  //the volume of oil layer
  G4Tubs* solidoilLayer = new G4Tubs("solidoilLayer",oilLayer[0],oilLayer[1],oilLayer[2]/2,0,360);
  logicaloilLayer = new G4LogicalVolume(solidoilLayer, Oil,"logicaloilLayer");
  physicaloilLayer = new G4PVPlacement(0,G4ThreeVector(0,0,0),logicaloilLayer,"physicaloilLayer",logicalPip,false,0);
 
  //the volume of outer Be pipe
   G4Tubs* solidouterBe = new G4Tubs("solidouterBe",outerBe[0],outerBe[1],outerBe[2]/2,0,360);
  logicalouterBe = new G4LogicalVolume(solidouterBe, G4Material::GetMaterial("Beryllium"),"logicalouterBe");
  physicalouterBe = new G4PVPlacement(0,G4ThreeVector(0,0,0),logicalouterBe,"physicalouterBe",logicalPip,false,0);
 
  //the volume of inner side Be layer
   G4Tubs* solidinnerBeSide = new G4Tubs("solidinnerBeSide",innerBeSide[0],innerBeSide[1],innerBeSide[2]/2,0,360);
  logicalinnerBeSide = new G4LogicalVolume(solidinnerBeSide, G4Material::GetMaterial("Beryllium"),"logicalinnerBeSide");
  physicalinnerBeSide = new G4PVPlacement(0,G4ThreeVector(0,0,innerBeSide[3]),logicalinnerBeSide,"physicalinnerBeSide1",logicalPip,false,0);
                        new G4PVPlacement(0,G4ThreeVector(0,0,innerBeSide[4]),logicalinnerBeSide,"physicalinnerBeSide2",logicalPip,false,1);
 
  //the volume of inner Al layer
   G4Tubs* solidinnerAl = new G4Tubs("solidinnerAl",innerAl[0],innerAl[1],innerAl[2]/2,0,360);
  logicalinnerAl = new G4LogicalVolume(solidinnerAl, G4Material::GetMaterial("Aluminium"),"logicalinnerAl");
  physicalinnerAl = new G4PVPlacement(0,G4ThreeVector(0,0,innerAl[3]),logicalinnerAl,"physicalinnerAl1",logicalPip,false,0);
                        new G4PVPlacement(0,G4ThreeVector(0,0,innerAl[4]),logicalinnerAl,"physicalinnerAl2",logicalPip,false,1);
 
  //the volume of Al ring
   G4Tubs* solidAlRing = new G4Tubs("solidAlRing",AlRing[0],AlRing[1],AlRing[2]/2,0,360);
  logicalAlRing = new G4LogicalVolume(solidAlRing, G4Material::GetMaterial("Aluminium"),"logicalAlRing");
  physicalAlRing = new G4PVPlacement(0,G4ThreeVector(0,0,AlRing[3]),logicalAlRing,"physicalAlRing1",logicalPip,false,0);
                        new G4PVPlacement(0,G4ThreeVector(0,0,AlRing[4]),logicalAlRing,"physicalAlRing2",logicalPip,false,1);
 
  //the volume of outer Al layer
   G4Tubs* solidouterAl = new G4Tubs("solidouterAl",outerAl[0],outerAl[1],outerAl[2]/2,0,360);
  logicalouterAl = new G4LogicalVolume(solidouterAl, G4Material::GetMaterial("Aluminium"),"logicalouterAl");
  physicalouterAl = new G4PVPlacement(0,G4ThreeVector(0,0,outerAl[3]),logicalouterAl,"physicalouterAl1",logicalPip,false,0);
                        new G4PVPlacement(0,G4ThreeVector(0,0,outerAl[4]),logicalouterAl,"physicalouterAl2",logicalPip,false,1);
 
  //the volume of Ag layer
   G4Tubs* solidAgLayer = new G4Tubs("solidAgLayer",AgLayer[0],AgLayer[1],AgLayer[2]/2,0,360);
  logicalAgLayer = new G4LogicalVolume(solidAgLayer, Ag,"logicalAgLayer");
  physicalAgLayer = new G4PVPlacement(0,G4ThreeVector(0,0,AgLayer[3]),logicalAgLayer,"physicalAgLayer1",logicalPip,false,0);
                        new G4PVPlacement(0,G4ThreeVector(0,0,AgLayer[4]),logicalAgLayer,"physicalAgLayer2",logicalPip,false,1);
 
  //the volume of  Cu layer
   G4Tubs* solidCuLayer = new G4Tubs("solidCuLayer",CuLayer[0],CuLayer[1],CuLayer[2]/2,0,360);
  logicalCuLayer = new G4LogicalVolume(solidCuLayer, G4Material::GetMaterial("Copper"),"logicalCuLayer");
  physicalCuLayer = new G4PVPlacement(0,G4ThreeVector(0,0,CuLayer[3]),logicalCuLayer,"physicalCuLayer1",logicalPip,false,0);
                        new G4PVPlacement(0,G4ThreeVector(0,0,CuLayer[4]),logicalCuLayer,"physicalCuLayer2",logicalPip,false,1);
 
  //the volume of Al cover
   G4Tubs* solidAlCover = new G4Tubs("solidAlCover",AlCover[0],AlCover[1],AlCover[2]/2,0,360);
  logicalAlCover = new G4LogicalVolume(solidAlCover, G4Material::GetMaterial("Aluminium"),"logicalAlCover");
  physicalAlCover = new G4PVPlacement(0,G4ThreeVector(0,0,AlCover[3]),logicalAlCover,"physicalAlCover1",logicalPip,false,0);
                        new G4PVPlacement(0,G4ThreeVector(0,0,AlCover[4]),logicalAlCover,"physicalAlCover2",logicalPip,false,1);
 
  G4VisAttributes* visPip = new G4VisAttributes(G4Colour(0.,0.,1.));
  logicalPip->SetVisAttributes(visPip);
  //logicalPip->SetVisAttributes(G4VisAttributes::Invisible);
  G4VisAttributes* visgold = new G4VisAttributes(G4Colour(1.,1.,0.));
  logicalgoldLayer->SetVisAttributes(visgold);
//  logicalgoldLayer->SetVisAttributes(G4VisAttributes::Invisible);
  G4VisAttributes* visBe = new G4VisAttributes(G4Colour(0.,1.,0.));
  logicalinnerBe->SetVisAttributes(visBe);
//  logicalinnerBe->SetVisAttributes(G4VisAttributes::Invisible);
  G4VisAttributes* visOil = new G4VisAttributes(G4Colour(1.,1.,1.));
  logicaloilLayer->SetVisAttributes(visOil);
//  logicaloilLayer->SetVisAttributes(G4VisAttributes::Invisible);
  logicalouterBe->SetVisAttributes(visBe);
//  logicalouterBe->SetVisAttributes(G4VisAttributes::Invisible);
  logicalinnerBeSide->SetVisAttributes(visBe);
//  logicalinnerBeSide->SetVisAttributes(G4VisAttributes::Invisible);
  logicalinnerAl->SetVisAttributes(visOil);
//  logicalinnerAl->SetVisAttributes(G4VisAttributes::Invisible);
  logicalAlRing->SetVisAttributes(visOil);
//  logicalAlRing->SetVisAttributes(G4VisAttributes::Invisible);
  logicalouterAl->SetVisAttributes(visOil);
//  logicalouterAl->SetVisAttributes(G4VisAttributes::Invisible);
  logicalAgLayer->SetVisAttributes(visBe);
//  logicalAgLayer->SetVisAttributes(G4VisAttributes::Invisible);
  logicalCuLayer->SetVisAttributes(visPip);
//  logicalCuLayer->SetVisAttributes(G4VisAttributes::Invisible);
  logicalAlCover->SetVisAttributes(visOil);
//  logicalAlCover->SetVisAttributes(G4VisAttributes::Invisible);
}

DefineMaterial()

void BesPip::DefineMaterial

(

)

Definition at line 91 of file BesPip.cc.

{
  G4double density, a, z,fractionmass;
  G4int nel,natoms;
  G4String name, symbol;
 
  density=19.32*g/cm3;
  a = 196.967*g/mole;
  Au= new G4Material("Gold",79,a,density);
 
  density=10.5*g/cm3;
  a = 107.9*g/mole;
  Ag= new G4Material("Silver",47,a,density);
 
  a = 1.01*g/mole;
  G4Element* H  = new G4Element(name="Hydrogen",symbol="H" , z= 1., a);
    
  a = 12.01*g/mole;
  G4Element* C  = new G4Element(name="Carbon"  ,symbol="C" , z= 6., a);
 
  density = 0.810*g/cm3;
  Oil = new G4Material(name="Oil",density,nel=2);
  Oil->AddElement(C, natoms=18);
  Oil->AddElement(H, natoms=38);
}

Referenced by Construct().

---

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

• BesPip.hh
• BesPip.cc