Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

BesPip Class Reference

#include <BesPip.hh>

Inheritance diagram for BesPip:

BesSubdetector BesSubdetector List of all members.

Public Member Functions

 BesPip ()
 BesPip ()
void Construct (G4LogicalVolume *logicbes)
void Construct (G4LogicalVolume *logicbes)
void DefineMaterial ()
void DefineMaterial ()
G4LogicalVolume * FindLogicalVolume (const G4String &vn)
G4LogicalVolume * FindLogicalVolume (const G4String &vn)
virtual ~BesPip ()
virtual ~BesPip ()

Protected Attributes

ProcessingConfigurator m_config
SAXProcessor m_sxp

Private Attributes

G4Material * Ag
G4Material * Ag
G4double AgLayer [5]
G4double AlCover [5]
G4double AlRing [5]
G4Material * Au
G4Material * Au
G4double CuLayer [5]
G4double goldLayer [3]
G4double innerAl [5]
G4double innerBe [3]
G4double innerBeSide [5]
G4LogicalVolume * logicalAgLayer
G4LogicalVolume * logicalAgLayer
G4LogicalVolume * logicalAlCover
G4LogicalVolume * logicalAlCover
G4LogicalVolume * logicalAlRing
G4LogicalVolume * logicalAlRing
G4LogicalVolume * logicalCuLayer
G4LogicalVolume * logicalCuLayer
G4LogicalVolume * logicalgoldLayer
G4LogicalVolume * logicalgoldLayer
G4LogicalVolume * logicalinnerAl
G4LogicalVolume * logicalinnerAl
G4LogicalVolume * logicalinnerBe
G4LogicalVolume * logicalinnerBe
G4LogicalVolume * logicalinnerBeSide
G4LogicalVolume * logicalinnerBeSide
G4LogicalVolume * logicaloilLayer
G4LogicalVolume * logicaloilLayer
G4LogicalVolume * logicalouterAl
G4LogicalVolume * logicalouterAl
G4LogicalVolume * logicalouterBe
G4LogicalVolume * logicalouterBe
G4LogicalVolume * logicalPip
G4LogicalVolume * logicalPip
G4Material * Oil
G4Material * Oil
G4double oilLayer [3]
G4double outerAl [5]
G4double outerBe [3]
G4VPhysicalVolume * physicalAgLayer
G4VPhysicalVolume * physicalAgLayer
G4VPhysicalVolume * physicalAlCover
G4VPhysicalVolume * physicalAlCover
G4VPhysicalVolume * physicalAlRing
G4VPhysicalVolume * physicalAlRing
G4VPhysicalVolume * physicalCuLayer
G4VPhysicalVolume * physicalCuLayer
G4VPhysicalVolume * physicalgoldLayer
G4VPhysicalVolume * physicalgoldLayer
G4VPhysicalVolume * physicalinnerAl
G4VPhysicalVolume * physicalinnerAl
G4VPhysicalVolume * physicalinnerBe
G4VPhysicalVolume * physicalinnerBe
G4VPhysicalVolume * physicalinnerBeSide
G4VPhysicalVolume * physicalinnerBeSide
G4VPhysicalVolume * physicaloilLayer
G4VPhysicalVolume * physicaloilLayer
G4VPhysicalVolume * physicalouterAl
G4VPhysicalVolume * physicalouterAl
G4VPhysicalVolume * physicalouterBe
G4VPhysicalVolume * physicalouterBe
G4VPhysicalVolume * physicalPip
G4VPhysicalVolume * physicalPip
BesPipParameter * pipPar
BesPipParameter * pipPar

Constructor & Destructor Documentation

BesPip::BesPip (   ) 
  

00026 {
00027   pipPar = new BesPipParameter();
00028   pipPar->ReadData();
00029   for(G4int i=0; i<3; i++)
00030   {
00031     goldLayer[i] = pipPar->getGoldLayer(i);
00032     innerBe[i] = pipPar->getInnerBe(i);
00033     oilLayer[i] = pipPar->getOilLayer(i);
00034     outerBe[i] = pipPar->getOuterBe(i);
00035   }
00036 
00037   for(G4int i=0; i<5; i++)
00038   {
00039     innerBeSide[i] = pipPar->getInnerBeSide(i);
00040     innerAl[i] = pipPar->getInnerAl(i);
00041     AlRing[i] = pipPar->getAlRing(i);
00042     outerAl[i] = pipPar->getOuterAl(i);
00043     AgLayer[i] = pipPar->getAgLayer(i);
00044     CuLayer[i] = pipPar->getCuLayer(i);
00045     AlCover[i] = pipPar->getAlCover(i);
00046   }
00047 
00048   logicalPip = 0;
00049   physicalPip = 0;
00050 
00051   logicalgoldLayer = 0;
00052   physicalgoldLayer = 0;
00053 
00054   logicalinnerBe = 0;
00055   physicalinnerBe = 0;
00056 
00057   logicaloilLayer = 0;
00058   physicaloilLayer = 0;
00059 
00060   logicalouterBe = 0;
00061   physicalouterBe = 0;
00062 
00063    logicalinnerBeSide = 0;
00064    physicalinnerBeSide = 0;
00065 
00066    logicalinnerAl = 0;
00067    physicalinnerAl = 0;
00068 
00069    logicalAlRing = 0;
00070    physicalAlRing = 0;
00071 
00072    logicalouterAl = 0;
00073    physicalouterAl = 0;
00074   
00075    logicalAgLayer = 0;
00076    physicalAgLayer = 0;
00077 
00078    logicalCuLayer = 0;
00079    physicalCuLayer = 0;
00080 
00081    logicalAlCover = 0;
00082    physicalAlCover = 0;
00083 
00084   Au = 0;
00085   Ag = 0;
00086   Oil = 0;
00087 }

virtual BesPip::~BesPip (   )  [inline, virtual]
  

00024 {;}

BesPip::BesPip (   ) 
 

virtual BesPip::~BesPip (   )  [inline, virtual]
  

00024 {;}

Member Function Documentation

void BesPip::Construct (  G4LogicalVolume *  logicbes  )  [virtual]
 

Implements BesSubdetector.

void BesPip::Construct (  G4LogicalVolume *  logicbes  )  [virtual]
 

Implements BesSubdetector.

00116 {
00117   DefineMaterial();
00118 
00119    //G4RotationMatrix* xRot = new G4RotationMatrix;
00120   //xRot->rotateX(90*deg);
00121 
00122   //the logical volume of beam pipe
00123   G4Tubs* solidPip1 = new G4Tubs("solidPip1",0.,33.7,134,0,360);
00124   G4Tubs* solidPip2 = new G4Tubs("solidPip2",0.,48,66,0,360);
00125   G4UnionSolid* solidPip_tmp = new G4UnionSolid("solidPip_tmp",solidPip1,solidPip2,0,G4ThreeVector(0,0,-167));
00126   G4UnionSolid* solidPip = new G4UnionSolid("solidPip",solidPip_tmp,solidPip2,0,G4ThreeVector(0,0,167));
00127   logicalPip = new G4LogicalVolume(solidPip, G4Material::GetMaterial("Beam"),"logicalPip");
00128   physicalPip = new G4PVPlacement(0,G4ThreeVector(0,0,0),logicalPip,"physicalPip",logicalbes,false,0);
00129 
00130   //the volume of gold layer
00131   G4Tubs* solidgoldLayer = new G4Tubs("solidgoldLayer",goldLayer[0],goldLayer[1],goldLayer[2]/2,0,360);
00132   logicalgoldLayer = new G4LogicalVolume(solidgoldLayer, Au,"logicalgoldLayer");
00133   physicalgoldLayer = new G4PVPlacement(0,G4ThreeVector(0,0,0),logicalgoldLayer,"physicalgoldLayer",logicalPip,false,0);
00134 
00135   //the volume of inner Be pipe
00136   G4Tubs* solidinnerBe = new G4Tubs("solidinnerBe",innerBe[0],innerBe[1],innerBe[2]/2,0,360);
00137   logicalinnerBe = new G4LogicalVolume(solidinnerBe, G4Material::GetMaterial("Beryllium"),"logicalinnerBe");
00138   physicalinnerBe = new G4PVPlacement(0,G4ThreeVector(0,0,0),logicalinnerBe,"physicalinnerBe",logicalPip,false,0);
00139 
00140   //the volume of oil layer
00141   G4Tubs* solidoilLayer = new G4Tubs("solidoilLayer",oilLayer[0],oilLayer[1],oilLayer[2]/2,0,360);
00142   logicaloilLayer = new G4LogicalVolume(solidoilLayer, Oil,"logicaloilLayer");
00143   physicaloilLayer = new G4PVPlacement(0,G4ThreeVector(0,0,0),logicaloilLayer,"physicaloilLayer",logicalPip,false,0);
00144 
00145   //the volume of outer Be pipe
00146    G4Tubs* solidouterBe = new G4Tubs("solidouterBe",outerBe[0],outerBe[1],outerBe[2]/2,0,360);
00147   logicalouterBe = new G4LogicalVolume(solidouterBe, G4Material::GetMaterial("Beryllium"),"logicalouterBe");
00148   physicalouterBe = new G4PVPlacement(0,G4ThreeVector(0,0,0),logicalouterBe,"physicalouterBe",logicalPip,false,0);
00149 
00150   //the volume of inner side Be layer
00151    G4Tubs* solidinnerBeSide = new G4Tubs("solidinnerBeSide",innerBeSide[0],innerBeSide[1],innerBeSide[2]/2,0,360);
00152   logicalinnerBeSide = new G4LogicalVolume(solidinnerBeSide, G4Material::GetMaterial("Beryllium"),"logicalinnerBeSide");
00153   physicalinnerBeSide = new G4PVPlacement(0,G4ThreeVector(0,0,innerBeSide[3]),logicalinnerBeSide,"physicalinnerBeSide1",logicalPip,false,0);
00154                         new G4PVPlacement(0,G4ThreeVector(0,0,innerBeSide[4]),logicalinnerBeSide,"physicalinnerBeSide2",logicalPip,false,1);
00155 
00156   //the volume of inner Al layer
00157    G4Tubs* solidinnerAl = new G4Tubs("solidinnerAl",innerAl[0],innerAl[1],innerAl[2]/2,0,360);
00158   logicalinnerAl = new G4LogicalVolume(solidinnerAl, G4Material::GetMaterial("Aluminium"),"logicalinnerAl");
00159   physicalinnerAl = new G4PVPlacement(0,G4ThreeVector(0,0,innerAl[3]),logicalinnerAl,"physicalinnerAl1",logicalPip,false,0);
00160                         new G4PVPlacement(0,G4ThreeVector(0,0,innerAl[4]),logicalinnerAl,"physicalinnerAl2",logicalPip,false,1);
00161 
00162   //the volume of Al ring
00163    G4Tubs* solidAlRing = new G4Tubs("solidAlRing",AlRing[0],AlRing[1],AlRing[2]/2,0,360);
00164   logicalAlRing = new G4LogicalVolume(solidAlRing, G4Material::GetMaterial("Aluminium"),"logicalAlRing");
00165   physicalAlRing = new G4PVPlacement(0,G4ThreeVector(0,0,AlRing[3]),logicalAlRing,"physicalAlRing1",logicalPip,false,0);
00166                         new G4PVPlacement(0,G4ThreeVector(0,0,AlRing[4]),logicalAlRing,"physicalAlRing2",logicalPip,false,1);
00167 
00168   //the volume of outer Al layer
00169    G4Tubs* solidouterAl = new G4Tubs("solidouterAl",outerAl[0],outerAl[1],outerAl[2]/2,0,360);
00170   logicalouterAl = new G4LogicalVolume(solidouterAl, G4Material::GetMaterial("Aluminium"),"logicalouterAl");
00171   physicalouterAl = new G4PVPlacement(0,G4ThreeVector(0,0,outerAl[3]),logicalouterAl,"physicalouterAl1",logicalPip,false,0);
00172                         new G4PVPlacement(0,G4ThreeVector(0,0,outerAl[4]),logicalouterAl,"physicalouterAl2",logicalPip,false,1);
00173 
00174   //the volume of Ag layer
00175    G4Tubs* solidAgLayer = new G4Tubs("solidAgLayer",AgLayer[0],AgLayer[1],AgLayer[2]/2,0,360);
00176   logicalAgLayer = new G4LogicalVolume(solidAgLayer, Ag,"logicalAgLayer");
00177   physicalAgLayer = new G4PVPlacement(0,G4ThreeVector(0,0,AgLayer[3]),logicalAgLayer,"physicalAgLayer1",logicalPip,false,0);
00178                         new G4PVPlacement(0,G4ThreeVector(0,0,AgLayer[4]),logicalAgLayer,"physicalAgLayer2",logicalPip,false,1);
00179 
00180   //the volume of  Cu layer
00181    G4Tubs* solidCuLayer = new G4Tubs("solidCuLayer",CuLayer[0],CuLayer[1],CuLayer[2]/2,0,360);
00182   logicalCuLayer = new G4LogicalVolume(solidCuLayer, G4Material::GetMaterial("Copper"),"logicalCuLayer");
00183   physicalCuLayer = new G4PVPlacement(0,G4ThreeVector(0,0,CuLayer[3]),logicalCuLayer,"physicalCuLayer1",logicalPip,false,0);
00184                         new G4PVPlacement(0,G4ThreeVector(0,0,CuLayer[4]),logicalCuLayer,"physicalCuLayer2",logicalPip,false,1);
00185 
00186   //the volume of Al cover
00187    G4Tubs* solidAlCover = new G4Tubs("solidAlCover",AlCover[0],AlCover[1],AlCover[2]/2,0,360);
00188   logicalAlCover = new G4LogicalVolume(solidAlCover, G4Material::GetMaterial("Aluminium"),"logicalAlCover");
00189   physicalAlCover = new G4PVPlacement(0,G4ThreeVector(0,0,AlCover[3]),logicalAlCover,"physicalAlCover1",logicalPip,false,0);
00190                         new G4PVPlacement(0,G4ThreeVector(0,0,AlCover[4]),logicalAlCover,"physicalAlCover2",logicalPip,false,1);
00191 
00192   G4VisAttributes* visPip = new G4VisAttributes(G4Colour(0.,0.,1.));
00193   logicalPip->SetVisAttributes(visPip);
00194   //logicalPip->SetVisAttributes(G4VisAttributes::Invisible);
00195   G4VisAttributes* visgold = new G4VisAttributes(G4Colour(1.,1.,0.));
00196   logicalgoldLayer->SetVisAttributes(visgold);
00197 //  logicalgoldLayer->SetVisAttributes(G4VisAttributes::Invisible);
00198   G4VisAttributes* visBe = new G4VisAttributes(G4Colour(0.,1.,0.));
00199   logicalinnerBe->SetVisAttributes(visBe);
00200 //  logicalinnerBe->SetVisAttributes(G4VisAttributes::Invisible);
00201   G4VisAttributes* visOil = new G4VisAttributes(G4Colour(1.,1.,1.));
00202   logicaloilLayer->SetVisAttributes(visOil);
00203 //  logicaloilLayer->SetVisAttributes(G4VisAttributes::Invisible);
00204   logicalouterBe->SetVisAttributes(visBe);
00205 //  logicalouterBe->SetVisAttributes(G4VisAttributes::Invisible);
00206   logicalinnerBeSide->SetVisAttributes(visBe);
00207 //  logicalinnerBeSide->SetVisAttributes(G4VisAttributes::Invisible);
00208   logicalinnerAl->SetVisAttributes(visOil);
00209 //  logicalinnerAl->SetVisAttributes(G4VisAttributes::Invisible);
00210   logicalAlRing->SetVisAttributes(visOil);
00211 //  logicalAlRing->SetVisAttributes(G4VisAttributes::Invisible);
00212   logicalouterAl->SetVisAttributes(visOil);
00213 //  logicalouterAl->SetVisAttributes(G4VisAttributes::Invisible);
00214   logicalAgLayer->SetVisAttributes(visBe);
00215 //  logicalAgLayer->SetVisAttributes(G4VisAttributes::Invisible);
00216   logicalCuLayer->SetVisAttributes(visPip);
00217 //  logicalCuLayer->SetVisAttributes(G4VisAttributes::Invisible);
00218   logicalAlCover->SetVisAttributes(visOil);
00219 //  logicalAlCover->SetVisAttributes(G4VisAttributes::Invisible);
00220 }

void BesPip::DefineMaterial (   ) 
 

void BesPip::DefineMaterial (   ) 
  

00090 {
00091   G4double density, a, z,fractionmass;
00092   G4int nel,natoms;
00093   G4String name, symbol;
00094 
00095   density=19.32*g/cm3;
00096   a = 196.967*g/mole;
00097   Au= new G4Material("Gold",79,a,density);
00098 
00099   density=10.5*g/cm3;
00100   a = 107.9*g/mole;
00101   Ag= new G4Material("Silver",47,a,density);
00102 
00103   a = 1.01*g/mole;
00104   G4Element* H  = new G4Element(name="Hydrogen",symbol="H" , z= 1., a);
00105     
00106   a = 12.01*g/mole;
00107   G4Element* C  = new G4Element(name="Carbon"  ,symbol="C" , z= 6., a);
00108 
00109   density = 0.810*g/cm3;
00110   Oil = new G4Material(name="Oil",density,nel=2);
00111   Oil->AddElement(C, natoms=18);
00112   Oil->AddElement(H, natoms=38);
00113 }

G4LogicalVolume* BesSubdetector::FindLogicalVolume (  const G4String &  vn  )  [inherited]
 

G4LogicalVolume * BesSubdetector::FindLogicalVolume (  const G4String &  vn  )  [inline, inherited]
  

00038                                                                        {
00039   return const_cast<G4LogicalVolume*>( GDMLProcessor::GetInstance()->GetLogicalVolume(vn) );
00040 }

Member Data Documentation

G4Material* BesPip::Ag [private]
 

G4Material* BesPip::Ag [private]
 

G4double BesPip::AgLayer [private]
 

G4double BesPip::AlCover [private]
 

G4double BesPip::AlRing [private]
 

G4Material* BesPip::Au [private]
 

G4Material* BesPip::Au [private]
 

G4double BesPip::CuLayer [private]
 

G4double BesPip::goldLayer [private]
 

G4double BesPip::innerAl [private]
 

G4double BesPip::innerBe [private]
 

G4double BesPip::innerBeSide [private]
 

G4LogicalVolume* BesPip::logicalAgLayer [private]
 

G4LogicalVolume* BesPip::logicalAgLayer [private]
 

G4LogicalVolume* BesPip::logicalAlCover [private]
 

G4LogicalVolume* BesPip::logicalAlCover [private]
 

G4LogicalVolume* BesPip::logicalAlRing [private]
 

G4LogicalVolume* BesPip::logicalAlRing [private]
 

G4LogicalVolume* BesPip::logicalCuLayer [private]
 

G4LogicalVolume* BesPip::logicalCuLayer [private]
 

G4LogicalVolume* BesPip::logicalgoldLayer [private]
 

G4LogicalVolume* BesPip::logicalgoldLayer [private]
 

G4LogicalVolume* BesPip::logicalinnerAl [private]
 

G4LogicalVolume* BesPip::logicalinnerAl [private]
 

G4LogicalVolume* BesPip::logicalinnerBe [private]
 

G4LogicalVolume* BesPip::logicalinnerBe [private]
 

G4LogicalVolume* BesPip::logicalinnerBeSide [private]
 

G4LogicalVolume* BesPip::logicalinnerBeSide [private]
 

G4LogicalVolume* BesPip::logicaloilLayer [private]
 

G4LogicalVolume* BesPip::logicaloilLayer [private]
 

G4LogicalVolume* BesPip::logicalouterAl [private]
 

G4LogicalVolume* BesPip::logicalouterAl [private]
 

G4LogicalVolume* BesPip::logicalouterBe [private]
 

G4LogicalVolume* BesPip::logicalouterBe [private]
 

G4LogicalVolume* BesPip::logicalPip [private]
 

G4LogicalVolume* BesPip::logicalPip [private]
 

ProcessingConfigurator BesSubdetector::m_config [protected, inherited]
 

SAXProcessor BesSubdetector::m_sxp [protected, inherited]
 

G4Material* BesPip::Oil [private]
 

G4Material* BesPip::Oil [private]
 

G4double BesPip::oilLayer [private]
 

G4double BesPip::outerAl [private]
 

G4double BesPip::outerBe [private]
 

G4VPhysicalVolume* BesPip::physicalAgLayer [private]
 

G4VPhysicalVolume* BesPip::physicalAgLayer [private]
 

G4VPhysicalVolume* BesPip::physicalAlCover [private]
 

G4VPhysicalVolume* BesPip::physicalAlCover [private]
 

G4VPhysicalVolume* BesPip::physicalAlRing [private]
 

G4VPhysicalVolume* BesPip::physicalAlRing [private]
 

G4VPhysicalVolume* BesPip::physicalCuLayer [private]
 

G4VPhysicalVolume* BesPip::physicalCuLayer [private]
 

G4VPhysicalVolume* BesPip::physicalgoldLayer [private]
 

G4VPhysicalVolume* BesPip::physicalgoldLayer [private]
 

G4VPhysicalVolume* BesPip::physicalinnerAl [private]
 

G4VPhysicalVolume* BesPip::physicalinnerAl [private]
 

G4VPhysicalVolume* BesPip::physicalinnerBe [private]
 

G4VPhysicalVolume* BesPip::physicalinnerBe [private]
 

G4VPhysicalVolume* BesPip::physicalinnerBeSide [private]
 

G4VPhysicalVolume* BesPip::physicalinnerBeSide [private]
 

G4VPhysicalVolume* BesPip::physicaloilLayer [private]
 

G4VPhysicalVolume* BesPip::physicaloilLayer [private]
 

G4VPhysicalVolume* BesPip::physicalouterAl [private]
 

G4VPhysicalVolume* BesPip::physicalouterAl [private]
 

G4VPhysicalVolume* BesPip::physicalouterBe [private]
 

G4VPhysicalVolume* BesPip::physicalouterBe [private]
 

G4VPhysicalVolume* BesPip::physicalPip [private]
 

G4VPhysicalVolume* BesPip::physicalPip [private]
 

BesPipParameter* BesPip::pipPar [private]
 

BesPipParameter* BesPip::pipPar [private]
 

The documentation for this class was generated from the following files:
Generated on Wed Feb 2 15:53:03 2011 for BOSS6.5.5 by  doxygen 1.3.9.1