Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/examples/advanced/composite_calorimeter/src/CCalG4Hcal.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /examples/advanced/composite_calorimeter/src/CCalG4Hcal.cc (Version 11.3.0) and /examples/advanced/composite_calorimeter/src/CCalG4Hcal.cc (Version 10.5)


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