source: trunk/examples/advanced/composite_calorimeter/src/CCalG4Hcal.cc @ 812

Last change on this file since 812 was 807, checked in by garnier, 16 years ago

update
File size: 13.5 KB
Line 
1//
2// ********************************************************************
3// * License and Disclaimer                                           *
4// *                                                                  *
5// * The  Geant4 software  is  copyright of the Copyright Holders  of *
6// * the Geant4 Collaboration.  It is provided  under  the terms  and *
7// * conditions of the Geant4 Software License,  included in the file *
8// * LICENSE and available at  http://cern.ch/geant4/license .  These *
9// * include a list of copyright holders.                             *
10// *                                                                  *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work  make  any representation or  warranty, express or implied, *
14// * regarding  this  software system or assume any liability for its *
15// * use.  Please see the license in the file  LICENSE  and URL above *
16// * for the full disclaimer and the limitation of liability.         *
17// *                                                                  *
18// * This  code  implementation is the result of  the  scientific and *
19// * technical work of the GEANT4 collaboration.                      *
20// * By using,  copying,  modifying or  distributing the software (or *
21// * any work based  on the software)  you  agree  to acknowledge its *
22// * use  in  resulting  scientific  publications,  and indicate your *
23// * acceptance of all terms of the Geant4 Software license.          *
24// ********************************************************************
25//
26///////////////////////////////////////////////////////////////////////////////
27// File: CCalG4Hcal.cc
28// Description: CCalG4Hcal Factory class to construct the G4 geometry of the
29//              hadron calorimeter
30///////////////////////////////////////////////////////////////////////////////
31#include "CCalG4Hcal.hh"
32
33#include "CCalMaterialFactory.hh"
34#include "CCalRotationMatrixFactory.hh"
35#include "CCalSensitiveDetectors.hh"
36
37#include "CCalutils.hh"
38#include <cmath>
39
40#include "G4ThreeVector.hh"
41#include "G4Box.hh"
42
43#include "G4LogicalVolume.hh"
44#include "G4PVPlacement.hh"
45
46//#define debug
47//#define ddebug
48//#define pdebug
49//#define sdebug
50
51////////////////////////////////////////////////////////////////////
52// CCalG4Hcal constructor & destructor...
53////////////////////////////////////////////////////////////////////
54
55CCalG4Hcal::CCalG4Hcal(const G4String &name):
56  CCalHcal(name), CCalG4Able(name), sclLog(0), absLog(0) {}
57
58CCalG4Hcal::~CCalG4Hcal(){
59  if (sclLog)
60    delete[] sclLog;
61  if (absLog)
62    delete[] absLog;
63}
64
65////////////////////////////////////////////////////////////////////
66// CCalG4Hcal methods...
67////////////////////////////////////////////////////////////////////
68
69G4VPhysicalVolume* CCalG4Hcal::constructIn(G4VPhysicalVolume* mother) {
70  G4cout << "==>> Constructing CCalG4Hcal..." << G4endl;
71
72  //Common logical volumes between methods.
73#ifdef debug
74  G4cout << tab << "Common logical volumes initialization: " 
75       << getNScintillator() << " scintillaor and " << getNAbsorber()
76       << " absorber layers." << G4endl;
77#endif
78  G4int i = 0;
79  sclLog  = new ptrG4Log[getNScintillator()];
80  absLog  = new ptrG4Log[getNAbsorber()];
81  for (i=0; i < getNScintillator(); i++)
82    sclLog[i]  = 0;
83  for (i=0; i < getNAbsorber(); i++)
84    absLog[i] = 0;
85
86  //Pointers to the Materials
87  CCalMaterialFactory* matfact       = CCalMaterialFactory::getInstance();
88
89  //Mother volume
90  G4Material* matter = matfact->findMaterial(getGenMat());
91  G4VSolid*   solid  = new G4Box (Name(), getDx_2Cal()*mm, getDy_2Cal()*mm,
92                                  getDy_2Cal()*mm);
93  G4LogicalVolume* logh = new G4LogicalVolume(solid, matter, Name());
94  setVisType(CCalVisualisable::PseudoVolumes,logh);
95#ifdef debug
96    G4cout << tab << Name() << " Box made of " << getGenMat()
97         << " of dimension " << getDx_2Cal()*mm << " " << getDy_2Cal()*mm
98         << " " << getDy_2Cal()*mm << G4endl;
99#endif
100
101  G4PVPlacement* hcal = new G4PVPlacement(0,G4ThreeVector(getXposCal()*mm,0,0),
102                                          Name(), logh, mother, false, 1);
103  G4String name("Null");
104#ifdef pdebug
105  if (mother != 0) name = mother->GetName();
106  G4cout << Name() << " Number 1 positioned in " << name << " at ("
107       << getXposCal()*mm << ",0,0) with no rotation" << G4endl;
108#endif
109
110  //Wall of the Boxes
111  solid  = new G4Box (name, 0.5*getWallThickBox()*mm, getDy_2Box()*mm, 
112                      getDy_2Box()*mm);
113  matter = matfact->findMaterial(getBoxMat());
114  name   = Name() + "Wall";
115  G4LogicalVolume* logw = new G4LogicalVolume(solid, matter, name);
116  setVisType(CCalVisualisable::Support,logw);
117#ifdef debug
118  G4cout << tab << name << " Box made of " << getBoxMat()
119       << " of dimension " << 0.5*getWallThickBox()*mm << " " 
120       << getDy_2Box()*mm << " " << getDy_2Box()*mm << G4endl;
121#endif
122
123  //Now the boxes
124  ptrG4Log* logb = new ptrG4Log[getNBox()];
125  matter = matfact->findMaterial(getGenMat());
126  for (i=0; i<getNBox(); i++) {
127    name   = Name() + "Box" + i;
128    solid  = new G4Box (name, getDx_2Box()*mm, getDy_2Box()*mm, 
129                        getDy_2Box()*mm);
130    logb[i]= new G4LogicalVolume(solid, matter, name);
131    setVisType(CCalVisualisable::PseudoVolumes,logb[i]);
132#ifdef debug
133    G4cout << tab << name << " Box made of " << getGenMat()
134         << " of dimension " << getDx_2Box()*mm << " " << getDy_2Box()*mm
135         << " " << getDy_2Box()*mm << G4endl;
136#endif
137
138    G4double xpos = -(getDx_2Box() - 0.5*getWallThickBox());
139    new G4PVPlacement (0, G4ThreeVector(xpos*mm,0,0), logw, logw->GetName(), 
140                       logb[i], false, 1);
141#ifdef pdebug
142    G4cout << logw->GetName() << " Number 1 positioned in " << name
143         << " at (" << xpos*mm << ",0,0) with no rotation" << G4endl;
144#endif
145    xpos = (getDx_2Box() - 0.5*getWallThickBox());
146    new G4PVPlacement (0, G4ThreeVector(xpos*mm,0,0), logw, logw->GetName(), 
147                       logb[i], false, 2);
148#ifdef pdebug
149    G4cout << logw->GetName() << " Number 2 positioned in " << name
150         << " at (" << xpos*mm << ",0,0) with no rotation" << G4endl;
151#endif
152
153    new G4PVPlacement (0, G4ThreeVector(getXposBox(i)*mm,0,0), logb[i], name, 
154                       logh, false, i+1);
155#ifdef pdebug
156    G4cout << name << " Number " << i+1 << " positioned in " << logh->GetName()
157         << " at (" << getXposBox(i)*mm << ",0,0) with no rotation" << G4endl;
158#endif
159  }
160
161  //Loop over scintillator layers
162  for (i=0; i<getNLayerScnt(); i++) {
163    G4int lay = getTypeScnt(i);
164    if (!sclLog[lay])
165      sclLog[lay] = constructScintillatorLayer(lay);
166    if (getMotherScnt(i) < 0 || getMotherScnt(i) >= getNScintillator()) {
167      logw = logh;
168    } else {
169      logw = logb[getMotherScnt(i)];
170    }
171    G4double xpos = getXposScnt(i);
172    new G4PVPlacement (0, G4ThreeVector(xpos*mm,0,0), sclLog[lay], 
173                       sclLog[lay]->GetName(), logw, false, i+1);
174#ifdef pdebug
175    G4cout << sclLog[lay]->GetName() << " Number " << i+1 << " positioned in " 
176         << logw->GetName() << " at (" << xpos*mm << ",0,0) with no rotation" 
177         << G4endl;
178#endif
179  }
180
181  //Loop over absorber layers
182  for (i=0; i<getNLayerAbs(); i++) {
183    G4int lay = getTypeAbs(i);
184    if (!absLog[lay])
185      absLog[lay] = constructAbsorberLayer(lay);
186    if (getMotherAbs(i) < 0 || getMotherAbs(i) >= getNAbsorber()) {
187      logw = logh;
188    } else {
189      logw = logb[getMotherAbs(i)];
190    }
191    G4double xpos = getXposAbs(i);
192    new G4PVPlacement (0, G4ThreeVector(xpos*mm,0,0), absLog[lay], 
193                       absLog[lay]->GetName(), logw, false, i+1);
194#ifdef pdebug
195    G4cout << absLog[lay]->GetName() << " Number " << i+1 << " positioned in " 
196         << logw->GetName() << " at (" << xpos*mm << ",0,0) with no rotation" 
197         << G4endl;
198#endif
199  }
200
201  delete [] logb;
202
203  G4cout << "<<== End of CCalG4Hcal construction ..." << G4endl;
204
205  return hcal;
206}
207
208
209G4LogicalVolume* CCalG4Hcal::constructScintillatorLayer(G4int lay) {
210
211  //Pointers to the Materials
212  CCalMaterialFactory* matfact       = CCalMaterialFactory::getInstance();
213
214  //The scintillator layer
215  G4Material* matter = matfact->findMaterial(getGenMat());
216  G4String    name   = Name() + "ScntLayer" + lay;
217  G4VSolid*   solid  = new G4Box (name, getDx_2ScntLay(lay)*mm, 
218                                  getDy_2ScntLay(lay)*mm,
219                                  getDy_2ScntLay(lay)*mm);
220  G4LogicalVolume* log = new G4LogicalVolume(solid, matter, name);
221  setVisType(CCalVisualisable::PseudoVolumes,log);
222#ifdef debug
223  G4cout << tab << name << " Box made of " << getGenMat() << " of dimension " 
224       << getDx_2ScntLay(lay)*mm << " " << getDy_2ScntLay(lay)*mm << " " 
225       << getDy_2ScntLay(lay)*mm << G4endl;
226#endif
227
228  G4LogicalVolume* logd;
229  G4double         xpos;
230  //Wrappers if any
231  if (getDx_2Wrap(lay) > 0) {
232    name   = Name() + "ScntWrapper" + lay;
233    matter = matfact->findMaterial(getWrapMat());
234    solid  = new G4Box (name, getDx_2Wrap(lay)*mm, 
235                        getDy_2ScntLay(lay)*mm, getDy_2ScntLay(lay)*mm);
236    logd   = new G4LogicalVolume(solid, matter, name);
237    setVisType(CCalVisualisable::Support,logd);
238#ifdef debug
239    G4cout << tab << name << " Box made of " << getWrapMat() << " of dimension " 
240         << getDx_2Wrap(lay)*mm << " " << getDy_2ScntLay(lay)*mm << " " 
241         << getDy_2ScntLay(lay)*mm << G4endl;
242#endif
243    xpos   =-(getDx_2ScntLay(lay)-getDx_2Wrap(lay));
244    new G4PVPlacement(0, G4ThreeVector(xpos*mm,0,0), logd, name, log, false,1);
245#ifdef pdebug
246    G4cout << logd->GetName() << " Number 1 positioned in " << log->GetName() 
247         << " at (" << xpos*mm << ",0,0) with no rotation" << G4endl;
248#endif
249    xpos   = (getDx_2ScntLay(lay)-getDx_2Wrap(lay));
250    new G4PVPlacement(0, G4ThreeVector(xpos*mm,0,0), logd, name, log, false,2);
251#ifdef pdebug
252    G4cout << logd->GetName() << " Number 2 positioned in " << log->GetName() 
253         << " at (" << xpos*mm << ",0,0) with no rotation" << G4endl;
254#endif
255  }
256
257  //Plastic covers
258  matter = matfact->findMaterial(getPlasMat());
259  name   = Name() + "FrontPlastic" + lay;
260  solid  = new G4Box (name, getDx_2FrontP(lay)*mm, getDy_2ScntLay(lay)*mm, 
261                      getDy_2ScntLay(lay)*mm);
262  logd   = new G4LogicalVolume(solid, matter, name);
263  setVisType(CCalVisualisable::Cable,logd);
264#ifdef debug
265  G4cout << tab << name << " Box made of " << getPlasMat() << " of dimension " 
266       << getDx_2FrontP(lay)*mm << " " << getDy_2ScntLay(lay)*mm << " " 
267       << getDy_2ScntLay(lay)*mm << G4endl;
268#endif
269  xpos   =-getDx_2ScntLay(lay)+2.*getDx_2Wrap(lay)+getDx_2FrontP(lay);
270  new G4PVPlacement(0, G4ThreeVector(xpos*mm,0,0), logd, name, log, false,1);
271#ifdef pdebug
272  G4cout << logd->GetName() << " Number 1 positioned in " << log->GetName() 
273       << " at (" << xpos*mm << ",0,0) with no rotation" << G4endl;
274#endif
275  name   = Name() + "BackPlastic" + lay;
276  solid  = new G4Box (name, getDx_2BackP(lay)*mm, getDy_2ScntLay(lay)*mm, 
277                      getDy_2ScntLay(lay)*mm);
278  logd   = new G4LogicalVolume(solid, matter, name);
279  setVisType(CCalVisualisable::Cable,logd);
280#ifdef debug
281  G4cout << tab << name << " Box made of " << getPlasMat() << " of dimension " 
282       << getDx_2BackP(lay)*mm << " " << getDy_2ScntLay(lay)*mm << " " 
283       << getDy_2ScntLay(lay)*mm << G4endl;
284#endif
285  xpos   =(-getDx_2ScntLay(lay)+2.*getDx_2Wrap(lay)+2.*getDx_2FrontP(lay)+
286           2.*getDx_2Scnt(lay)+getDx_2BackP(lay));
287  new G4PVPlacement(0, G4ThreeVector(xpos*mm,0,0), logd, name, log, false,1);
288#ifdef pdebug
289  G4cout << logd->GetName() << " Number 1 positioned in " << log->GetName() 
290       << " at (" << xpos*mm << ",0,0) with no rotation" << G4endl;
291#endif
292
293  //Now the scintillators
294  matter = matfact->findMaterial(getScntMat());
295  name   = Name() + "Scintillator" + lay;
296  solid  = new G4Box (name, getDx_2Scnt(lay)*mm, getDy_2ScntLay(lay)*mm, 
297                      getDy_2ScntLay(lay)*mm);
298  logd   = new G4LogicalVolume(solid, matter, name);
299  setVisType(CCalVisualisable::Sensitive,logd);
300  allSensitiveLogs.push_back(logd);
301#ifdef debug
302  G4cout << tab << name << " Box made of " << getScntMat() << " of dimension " 
303       << getDx_2Scnt(lay)*mm << " " << getDy_2ScntLay(lay)*mm << " " 
304       << getDy_2ScntLay(lay)*mm << G4endl;
305#endif
306  xpos   =(-getDx_2ScntLay(lay)+2.*getDx_2Wrap(lay)+2.*getDx_2FrontP(lay)+
307           getDx_2Scnt(lay));
308  new G4PVPlacement(0, G4ThreeVector(xpos*mm,0,0), logd, name, log, false,1);
309#ifdef pdebug
310  G4cout << logd->GetName() << " Number 1 positioned in " << log->GetName() 
311       << " at (" << xpos*mm << ",0,0) with no rotation" << G4endl;
312#endif
313
314  return log;
315}
316
317
318G4LogicalVolume* CCalG4Hcal::constructAbsorberLayer(G4int lay) {
319
320  //Pointers to the Materials
321  CCalMaterialFactory* matfact       = CCalMaterialFactory::getInstance();
322
323  //Now the absorber layer
324  G4Material* matter = matfact->findMaterial(getAbsMat());
325  G4String    name   = Name() + "Absorber" + lay;
326  G4VSolid*   solid  = new G4Box (name, getDx_2Abs(lay)*mm, getDy_2Abs()*mm,
327                                  getDy_2Abs()*mm);
328  G4LogicalVolume* log = new G4LogicalVolume(solid, matter, name);
329  setVisType(CCalVisualisable::Absorber,log);
330#ifdef debug
331  G4cout << tab << name << " Box made of " << getAbsMat() << " of dimension " 
332       << getDx_2Abs(lay)*mm << " " << getDy_2Abs()*mm << " " 
333       << getDy_2Abs()*mm << G4endl;
334#endif
335
336  return log;
337}
338
339
340void CCalG4Hcal::constructSensitive(){
341
342  if (allSensitiveLogs.size()>0) {
343    CCalSensitiveDetectors* sensDets = CCalSensitiveDetectors::getInstance();
344    G4String SDname = Name();
345    for (std::vector<ptrG4Log>::iterator iter=allSensitiveLogs.begin(); 
346         iter<allSensitiveLogs.end(); iter++) {
347      sensDets->registerVolume(SDname, (*iter));
348#ifdef sdebug
349      G4cout << "Register volume " << (*iter)->GetName() << " for" << SDname
350           << G4endl;
351#endif
352    }
353  } else {
354    G4cerr << "CCalG4Hcal ERROR: Could not construct Sensitive Detector" 
355           << G4endl;
356  }
357}
358
359void CCalG4Hcal::constructDaughters() {}
Note: See TracBrowser for help on using the repository browser.