77 ISvcLocator *svcLocator = Gaudi::svcLocator();
81 log <<
MSG::DEBUG <<
"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++" <<
endmsg;
85 log <<
MSG::DEBUG <<
"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++" <<
endmsg;
89 if (svcLocator->service(
"DetectorStore",
detStore,
false )==StatusCode::FAILURE) {
90 throw std::runtime_error(
"Error in HECModuleConstruction, cannot access DetectorStore");
95 if (StatusCode::SUCCESS !=
detStore->retrieve(materialManager, std::string(
"MATERIALS"))) {
96 throw std::runtime_error(
"Error in HECModuleConstruction, cannot access Material Manager");
99 const GeoMaterial *
LAr = materialManager->
getMaterial(
"std::LiquidArgon");
100 if (!
LAr)
throw std::runtime_error(
"Error in HECModuleConstruction, std::LiquidArgon is not found.");
102 const GeoMaterial *Iron = materialManager->
getMaterial(
"std::Iron");
103 if (!Iron)
throw std::runtime_error(
"Error in HECModuleConstruction, std::Iron is not found.");
105 const GeoMaterial *Copper = materialManager->
getMaterial(
"std::Copper");
106 if (!Copper)
throw std::runtime_error(
"Error in HECModuleConstruction, std::Copper is not found.");
108 const GeoMaterial *Kapton = materialManager->
getMaterial(
"std::Kapton");
109 if (!Kapton)
throw std::runtime_error(
"Error in HECModuleConstruction, std::Kapton is not found.");
115 sc=svcLocator->service(
"RDBAccessSvc",pAccessSvc);
116 if (
sc != StatusCode::SUCCESS) {
117 throw std::runtime_error (
"Cannot locate RDBAccessSvc!!");
122 sc = svcLocator->service (
"GeoModelSvc",geoModel);
123 if (
sc != StatusCode::SUCCESS) {
124 throw std::runtime_error (
"Cannot locate GeoModelSvc!!");
130 std::string detectorKey = LArVersion.empty() ?
AtlasVersion : LArVersion;
131 std::string detectorNode = LArVersion.empty() ?
"ATLAS" :
"LAr";
134 if(hadronicEndcap->size()>0)
135 log <<
MSG::DEBUG <<
"Using numbers from HadronicEndcap tag: " << hadronicEndcap->tagName() <<
endmsg;
137 throw std::runtime_error(
"Error in HECConstruction: hadronicEendcap not found");
140 if(hecLongitudinalBlock->size()>0)
141 log <<
MSG::DEBUG <<
"Using numbers from HecLongitudinalBlock tag: " << hecLongitudinalBlock->tagName() <<
endmsg;
143 throw std::runtime_error(
"Error in HECConstruction: hecLongitudinalBlock not found");
149 double shrinkCold = 1.0;
152 int moduleNumber = (*hadronicEndcap)[0]->getInt(
"NSCT");
153 double moduleRinner1 = shrinkCold * (*hecLongitudinalBlock)[0]->getDouble(
"BLRMN")*
cm;
154 double moduleRinner2 = shrinkCold * (*hecLongitudinalBlock)[1]->getDouble(
"BLRMN")*
cm;
155 double moduleRouter = shrinkCold * (*hecLongitudinalBlock)[0]->getDouble(
"BLRMX")*
cm;
156 if (
m_tbyear==2004) moduleRouter = moduleRinner1 + 787*
mm;
157 double copperPad = shrinkCold * (*hadronicEndcap)[0]->getDouble(
"COPPER")*
cm;
158 double gapSize = shrinkCold * (*hadronicEndcap)[0]->getDouble(
"LARG")*
cm;
159 double drModOverlap = shrinkCold * (*hadronicEndcap)[0]->getDouble(
"DRMODOVERLAP")*
cm;
160 double kaptonWidth[2];
161 kaptonWidth[0] = shrinkCold * (*hadronicEndcap)[0]->getDouble(
"ESTPL")*
cm;
162 kaptonWidth[1] = shrinkCold * (*hadronicEndcap)[0]->getDouble(
"PADPL")*
cm;
164 for(
int id=0;
id<7;
id++) gapN[
id] = (
int) (*hecLongitudinalBlock)[
id]->getDouble(
"BLMOD");
165 double firstFrontAbsThickness= shrinkCold * (*hecLongitudinalBlock)[0]->getDouble(
"PLATE0")*
cm;
166 double firstRearAbsThickness = shrinkCold * (*hecLongitudinalBlock)[3]->getDouble(
"PLATE0")*
cm;
167 double frontAbsThickness = shrinkCold * (*hadronicEndcap)[0]->getDouble(
"PLATE_0")*
cm;
168 double rearAbsThickness = shrinkCold * (*hadronicEndcap)[0]->getDouble(
"PLATE_1")*
cm;
169 double tieRodPositionX[4];
170 double tieRodPositionY[4];
171 tieRodPositionX[0] = shrinkCold * (*hadronicEndcap)[0]->getDouble(
"RODPOSX_0")*
cm;
172 tieRodPositionY[0] = shrinkCold * (*hadronicEndcap)[0]->getDouble(
"RODPOSR_0")*
cm;
173 tieRodPositionX[1] = shrinkCold * (*hadronicEndcap)[0]->getDouble(
"RODPOSX_1")*
cm;
174 tieRodPositionY[1] = shrinkCold * (*hadronicEndcap)[0]->getDouble(
"RODPOSR_1")*
cm;
175 tieRodPositionX[2] = shrinkCold * (*hadronicEndcap)[0]->getDouble(
"RODPOSX_2")*
cm;
176 tieRodPositionY[2] = shrinkCold * (*hadronicEndcap)[0]->getDouble(
"RODPOSR_2")*
cm;
177 tieRodPositionX[3] = shrinkCold * (*hadronicEndcap)[0]->getDouble(
"RODPOSX_3")*
cm;
178 tieRodPositionY[3] = shrinkCold * (*hadronicEndcap)[0]->getDouble(
"RODPOSR_3")*
cm;
179 double tieRodDiameter = shrinkCold * (*hadronicEndcap)[0]->getDouble(
"RODDIM_0")*
cm;
180 double spacerDiameter = shrinkCold * (*hadronicEndcap)[0]->getDouble(
"SPCDIM_0")*
cm;
181 double spacerDeadZone = shrinkCold * 3.0*
mm;
184 tieRodDiameter = shrinkCold * (*hadronicEndcap)[0]->getDouble(
"RODDIM_1")*
cm;
185 spacerDiameter = shrinkCold * (*hadronicEndcap)[0]->getDouble(
"SPCDIM_1")*
cm;
192 int depthOffset = depthNumber;
193 double absThickness = frontAbsThickness;
194 double firstAbsThickness = firstFrontAbsThickness;
197 if (
m_tb) depthNumber= 2;
198 absThickness = rearAbsThickness;
199 firstAbsThickness = firstRearAbsThickness;
205 depthS[0] = firstFrontAbsThickness + gapN[0]*(frontAbsThickness+gapSize);
206 depthS[1] = gapN[1]*(frontAbsThickness+gapSize);
207 depthS[2] = gapN[2]*(frontAbsThickness+gapSize);
208 depthS[3] = firstRearAbsThickness + gapN[3]*(rearAbsThickness+gapSize);
209 depthS[4] = gapN[4]*(rearAbsThickness+gapSize);
210 depthS[5] = gapN[5]*(rearAbsThickness+gapSize);
211 depthS[6] = gapN[6]*(rearAbsThickness+gapSize);
215 double zCoordinate[4];
219 double g4allow = shrinkCold * 0.1*
mm ;
220 double g4allowS = 0.001*
mm ;
222 zCoordinate[0] = shrinkCold * 0.0*
cm;
223 zCoordinate[1] = depthS[0];
224 zCoordinate[2] = depthS[0] + g4allow;
225 zCoordinate[3] = depthS[0]+depthS[1]+depthS[2] + g4allow;
227 for (
int i=0;
i<3;
i++) {
228 if (
i>0) gaptally[
i] = gaptally[
i-1] + gapN[
i-1];
229 gapNumber[
i] = gapN[
i];
230 depthSize[
i] = depthS[
i];
234 zCoordinate[0] = shrinkCold * 0.0*
cm;
235 zCoordinate[1] = depthS[3]+depthS[4]+depthS[5]+depthS[6]+g4allow;
236 if(
m_tb) zCoordinate[1]= depthS[3]+depthS[4]+g4allow;
238 for (
int i=0;
i<4;
i++) {
239 if (
i>0) gaptally[
i] =gaptally[
i-1] + gapN[
i+3-1];
240 gapNumber[
i] = gapN[
i+3];
241 depthSize[
i] = depthS[
i+3];
256 double halfGap = gapSize/2.;
257 double halfGapLAr = (gapSize - kaptonWidth[1])/2.;
258 double restLAr = (halfGapLAr-kaptonWidth[0])/2. ;
259 ztie[0] = restLAr/2 + kaptonWidth[1]/2.;
260 ztie[1] = halfGap - restLAr/2.;
261 rodSize = restLAr - g4allowS;
265 double halfGap = gapSize/2.;
266 double halfGapLAr = (gapSize - kaptonWidth[1])/2. - kaptonWidth[0];
267 ztie[0] = (halfGap-halfGapLAr/2.);
269 rodSize = halfGapLAr-g4allowS;
278 double modulePhistart = 264.375*
deg;
279 double moduleDeltaPhi = 2*
M_PI/moduleNumber;
287 double deadZone = shrinkCold * 3.*
mm;
288 double larShift = deadZone /
sin(moduleDeltaPhi/2.);
293 double deadGap = shrinkCold * 1.*
mm;
294 double radialShift = deadGap /
sin(moduleDeltaPhi/2.);
309 std::string moduleName =
"LAr::HEC::Module";
310 std::string depthName = moduleName +
"::Depth";
311 std::string sliceName = depthName +
"::Slice";
312 std::string electrodeName = sliceName +
"::Electrode";
313 std::string copperName = electrodeName +
"::Copper";
314 std::string tieRodName = sliceName +
"::TieRod";
315 std::string deadTieName = sliceName +
"::TieRodDead";
316 std::string absorberName = depthName +
"::Absorber";
317 std::string firstAbsorberName = depthName +
"::FirstAbsorber";
318 std::string absTieRodName = absorberName +
"::TieRod";
319 std::string firstabsTieRodName = firstAbsorberName +
"::TieRod";
323 GeoIntrusivePtr<GeoTubs>solidAbsorberTieRod =
new GeoTubs(0.*
cm,tieRodDiameter/2.,absThickness/2.,0.*
deg,360.*
deg);
324 GeoIntrusivePtr<GeoLogVol> logiAbsorberTieRod =
new GeoLogVol(absTieRodName,solidAbsorberTieRod,Iron);
325 GeoIntrusivePtr<GeoPhysVol> physiAbsorberTieRod =
new GeoPhysVol(logiAbsorberTieRod);
327 GeoIntrusivePtr<GeoTubs> solidFirstAbsorberTieRod =
new GeoTubs(0.*
cm,tieRodDiameter/2.,firstAbsThickness/2.,0.*
deg,360.*
deg);
328 GeoIntrusivePtr<GeoLogVol> logiFirstAbsorberTieRod =
new GeoLogVol(firstabsTieRodName,solidFirstAbsorberTieRod,Iron);
329 GeoIntrusivePtr<GeoPhysVol> physiFirstAbsorberTieRod =
new GeoPhysVol(logiFirstAbsorberTieRod);
334 GeoIntrusivePtr<GeoTubs> solidTieRod =
new GeoTubs(0.*
cm,spacerDiameter/2.,rodSize/2.,0.*
deg,360.*
deg);
335 GeoIntrusivePtr<GeoLogVol> logiTieRod =
new GeoLogVol(tieRodName, solidTieRod, Iron);
336 GeoIntrusivePtr<GeoPhysVol> physiTieRod =
new GeoPhysVol(logiTieRod);
339 GeoIntrusivePtr<GeoTubs> solidDeadTie =
new GeoTubs(g4allowS+spacerDiameter/2.,
340 spacerDeadZone+spacerDiameter/2.,
343 GeoIntrusivePtr<GeoLogVol> logiDeadTie =
new GeoLogVol(deadTieName, solidDeadTie,
LAr);
344 GeoIntrusivePtr<GeoPhysVol> physiDeadTie =
new GeoPhysVol(logiDeadTie);
354 std::array<GeoIntrusivePtr<GeoTubs>, 2> solidPadBoard{};
355 std::array<GeoIntrusivePtr<GeoLogVol>, 2> logiPadBoard{};
356 std::array<GeoIntrusivePtr<GeoPhysVol>, 2> physiPadBoard{};
358 std::array<GeoIntrusivePtr<GeoTubs>, 2> solidCopperPad{};
359 std::array<GeoIntrusivePtr<GeoLogVol>, 2> logiCopperPad{};
360 std::array<GeoIntrusivePtr<GeoPhysVol>, 2> physiCopperPad{};
362 std::array<GeoIntrusivePtr<GeoTubs>, 2> solidEstBoard{};
363 std::array<GeoIntrusivePtr<GeoLogVol>, 2> logiEstBoard{};
364 std::array<GeoIntrusivePtr<GeoPhysVol>, 2> physiEstBoard{};
366 std::array<GeoIntrusivePtr<GeoTubs>, 2> solidSlice{};
367 std::array<GeoIntrusivePtr<GeoLogVol>, 2> logiSlice{};
368 std::array<GeoIntrusivePtr<GeoPhysVol>,2> physiSlice{};
370 std::array<GeoIntrusivePtr<GeoTubs>,2> solidAbsorber{};
371 std::array<GeoIntrusivePtr<GeoLogVol>,2> logiAbsorber{};
372 std::array<GeoIntrusivePtr<GeoPhysVol>,2> physiAbsorber{};
375 double rOuterF = moduleRouter-radialShift;
376 double rInnerF = moduleRinner2-radialShift;
378 GeoIntrusivePtr<GeoTubs> solidFirstAbsorber =
new GeoTubs(rInnerF,rOuterF,
379 firstAbsThickness/2.,
380 modulePhistart,moduleDeltaPhi);
381 GeoIntrusivePtr<GeoLogVol> logiFirstAbsorber =
new GeoLogVol(firstAbsorberName, solidFirstAbsorber, Copper);
382 GeoIntrusivePtr<GeoPhysVol> physiFirstAbsorber =
new GeoPhysVol(logiFirstAbsorber);
385 for(
int iSect=0; iSect<sectMax; iSect++)
392 double rOuter = moduleRouter - larShift - deadZone;
393 double rInner = moduleRinner2 - larShift + deadZone;
394 if (iSect<1 &&
m_frontWheel) rInner = moduleRinner1 - larShift + deadZone;
395 solidSlice[iSect] =
new GeoTubs(rInner, rOuter, gapSize/2., modulePhistart, moduleDeltaPhi);
396 logiSlice[iSect] =
new GeoLogVol(sliceName, solidSlice[iSect],
LAr);
397 physiSlice[iSect] =
new GeoPhysVol(logiSlice[iSect]);
400 rOuter = moduleRouter - larShift - deadZone -g4allowS;
401 rInner = moduleRinner2 - larShift + deadZone +g4allowS;
402 if (
m_frontWheel && iSect==0) rInner = moduleRinner1 - larShift + deadZone +g4allowS ;
407 solidPadBoard[iSect] =
new GeoTubs(rInner,rOuter,
409 modulePhistart,moduleDeltaPhi);
412 solidPadBoard[iSect] =
new GeoTubs(rInner,rOuter,
413 (kaptonWidth[1]/2.+ kaptonWidth[0]),
414 modulePhistart,moduleDeltaPhi);
416 logiPadBoard[iSect] =
new GeoLogVol(electrodeName, solidPadBoard[iSect], Kapton );
417 physiPadBoard[iSect] =
new GeoPhysVol(logiPadBoard[iSect]);
420 solidCopperPad[iSect] =
new GeoTubs(rInner,rOuter,copperPad/2.,
421 modulePhistart,moduleDeltaPhi);
422 logiCopperPad[iSect] =
new GeoLogVol(copperName, solidCopperPad[iSect], Copper);
423 physiCopperPad[iSect] =
new GeoPhysVol(logiCopperPad[iSect]);
424 physiPadBoard[iSect]->add(physiCopperPad[iSect]);
428 solidEstBoard[iSect] =
new GeoTubs(rInner,rOuter,kaptonWidth[0]/2.,
429 modulePhistart,moduleDeltaPhi);
430 logiEstBoard[iSect] =
new GeoLogVol(electrodeName, solidEstBoard[iSect], Kapton );
431 physiEstBoard[iSect] =
new GeoPhysVol(logiEstBoard[iSect]);
436 physiSlice[iSect]->add(
new GeoIdentifierTag(1));
437 physiSlice[iSect]->add(physiPadBoard[iSect]);
442 double halfGapLAr = (gapSize - kaptonWidth[1])/2.;
443 double ESTPos = (kaptonWidth[1]+halfGapLAr)/2.;
444 physiSlice[iSect]->add(
new GeoIdentifierTag(0));
445 physiSlice[iSect]->add(
new GeoTransform(Translate3D(0,0,(-ESTPos))));
446 physiSlice[iSect]->add(physiEstBoard[iSect]);
447 physiSlice[iSect]->add(
new GeoIdentifierTag(2));
448 physiSlice[iSect]->add(
new GeoTransform(Translate3D(0,0,ESTPos)));
449 physiSlice[iSect]->add(physiEstBoard[iSect]);
457 rOuter = moduleRouter - radialShift;
458 rInner = moduleRinner2 - radialShift;
459 if (iSect<1 &&
m_frontWheel) rInner = moduleRinner1 - radialShift;
460 solidAbsorber[iSect] =
new GeoTubs(rInner,rOuter,absThickness/2., modulePhistart,moduleDeltaPhi);
461 logiAbsorber[iSect] =
new GeoLogVol(absorberName, solidAbsorber[iSect], Copper);
462 physiAbsorber[iSect] =
new GeoPhysVol(logiAbsorber[iSect]);
472 for(
int indexRod=1; indexRod<nRods; indexRod++) {
473 for(
double isignX=-1;isignX<2;isignX=isignX+2.){
475 physiAbsorber[iSect]->add(
new GeoIdentifierTag(indexRod));
476 physiAbsorber[iSect]->add(
new GeoTransform(Translate3D(isignX*tieRodPositionX[indexRod],
477 -tieRodPositionY[indexRod]+radialShift, 0)));
478 physiAbsorber[iSect]->add(physiAbsorberTieRod);
480 physiFirstAbsorber->add(
new GeoIdentifierTag(indexRod));
481 physiFirstAbsorber->add(
new GeoTransform(Translate3D(isignX*tieRodPositionX[indexRod],
482 -tieRodPositionY[indexRod]+radialShift, 0)));
483 physiFirstAbsorber->add(physiFirstAbsorberTieRod);
488 for(
int itie=0; itie<2; itie++ ){
489 for(
double isignZ=-1;isignZ<2;isignZ=isignZ+2.){
490 physiSlice[iSect]->add(
new GeoIdentifierTag(indexRod));
491 physiSlice[iSect]->add(
new GeoTransform
492 (Translate3D(isignX*tieRodPositionX[indexRod],
493 -tieRodPositionY[indexRod]+larShift,
495 if (itie==0) { physiSlice[iSect]->add(physiTieRod); }
496 else { physiSlice[iSect]->add(physiDeadTie);}
499 physiSlice[iSect]->add(
new GeoIdentifierTag(indexRod));
500 physiSlice[iSect]->add(
new GeoTransform
501 (Translate3D(isignX*tieRodPositionX[indexRod],
502 -tieRodPositionY[indexRod]+larShift,
504 if (itie==0) { physiSlice[iSect]->add(physiTieRod); }
505 else { physiSlice[iSect]->add(physiDeadTie);}
516 physiAbsorber[iSect]->add(
new GeoIdentifierTag(0));
517 physiAbsorber[iSect]->add(
new GeoTransform(Translate3D(tieRodPositionX[0],
518 -tieRodPositionY[0]+radialShift,0)));
519 physiAbsorber[iSect]->add(physiAbsorberTieRod);
521 physiFirstAbsorber->add(
new GeoIdentifierTag(0));
522 physiFirstAbsorber->add(
new GeoTransform(Translate3D(tieRodPositionX[0],
523 -tieRodPositionY[0]+radialShift,0)));
524 physiFirstAbsorber->add(physiFirstAbsorberTieRod);
528 for(
int itie=0; itie<2; itie++ ){
529 for(
double isignZ=-1;isignZ<2;isignZ=isignZ+2){
530 physiSlice[iSect]->add(
new GeoIdentifierTag(0));
531 physiSlice[iSect]->add(
new GeoTransform(Translate3D(tieRodPositionX[0],
532 -tieRodPositionY[0]+larShift,
534 if (itie==0) { physiSlice[iSect]->add(physiTieRod); }
535 else { physiSlice[iSect]->add(physiDeadTie);}
538 physiSlice[iSect]->add(
new GeoIdentifierTag(0));
539 physiSlice[iSect]->add(
new GeoTransform(Translate3D(tieRodPositionX[0],
540 -tieRodPositionY[0]+larShift,
542 if (itie==0) { physiSlice[iSect]->add(physiTieRod); }
543 else { physiSlice[iSect]->add(physiDeadTie);}
562 std::array<GeoIntrusivePtr<GeoTubs>, 4> solidDepth{};
563 std::array<GeoIntrusivePtr<GeoLogVol>, 4> logiDepth{};
564 std::array<GeoIntrusivePtr<GeoPhysVol>, 4> physiDepth{};
566 for(
int iDepth=0; iDepth<depthNumber; iDepth++)
568 double rOuter = moduleRouter;
569 double rInner = moduleRinner2;
571 solidDepth[iDepth] =
new GeoTubs(rInner-drModOverlap,rOuter,
572 depthSize[iDepth]/2.,modulePhistart,moduleDeltaPhi);
573 logiDepth[iDepth] =
new GeoLogVol(depthName, solidDepth[iDepth],
LAr);
574 physiDepth[iDepth] =
new GeoPhysVol(logiDepth[iDepth]);
579 double firstAbs = 0.;
580 if (iDepth==0) firstAbs = firstAbsThickness;
581 double slicePositionZ = firstAbs + gapSize/2.0 -depthSize[iDepth]/2.0;
582 double absorberPositionZ = firstAbs + gapSize + absThickness/2.0 - depthSize[iDepth]/2.0;
595 sliceCopyNo += gaptally[iDepth];
600 GeoGenfun::Variable
Index;
601 GeoXF::TRANSFUNCTION
TS =
602 TranslateY3D(-larShift)*GeoXF::Pow(TranslateZ3D(1.0),slicePositionZ + (absThickness+gapSize)*
Index);
603 GeoXF::TRANSFUNCTION
TA =
604 TranslateY3D(-radialShift)*GeoXF::Pow(TranslateZ3D(1.0),absorberPositionZ + (absThickness+gapSize)*
Index);
606 GeoSerialIdentifier *sI =
new GeoSerialIdentifier(sliceCopyNo);
607 GeoSerialTransformer *sTS =
new GeoSerialTransformer(physiSlice[sliceNo], &
TS, gapNumber[iDepth]);
608 GeoSerialTransformer *sTAF =
new GeoSerialTransformer(physiAbsorber[sliceNo], &TA, gapNumber[iDepth]);
609 physiDepth[iDepth]->add(sI);
610 physiDepth[iDepth]->add(sTS);
611 physiDepth[iDepth]->add(sI);
612 physiDepth[iDepth]->add(sTAF);
618 double firstAbsorberPositionZ = firstAbsThickness/2.- depthSize[0]/2.0;
619 if(
m_frontWheel) physiDepth[0]->add(
new GeoIdentifierTag(0));
620 else physiDepth[0]->add(
new GeoIdentifierTag(1));
621 physiDepth[0]->add(
new GeoTransform(Translate3D(0,-radialShift,firstAbsorberPositionZ)));
622 physiDepth[0]->add(physiFirstAbsorber);
630 GeoPcon* solidHECModule =
new GeoPcon(modulePhistart, moduleDeltaPhi);
631 for (
int i=0;
i< nZplane;
i++)
633 double innerRadius = moduleRinner2;
635 solidHECModule->addPlane(zCoordinate[
i],innerRadius-drModOverlap,moduleRouter);
637 GeoIntrusivePtr<GeoLogVol> logicHECModule =
new GeoLogVol(moduleName, solidHECModule ,
LAr);
638 GeoIntrusivePtr<GeoFullPhysVol> physiHECModule =
new GeoFullPhysVol(logicHECModule);
643 double depthPositionZ = 0.;
645 for(
int iDepth=0; iDepth<depthNumber; iDepth++)
647 depthPositionZ +=depthSize[iDepth]/2.;
648 if(!
m_frontWheel) physiHECModule->add(
new GeoIdentifierTag(iDepth+depthOffset));
649 else physiHECModule->add(
new GeoIdentifierTag(iDepth));
650 physiHECModule->add(
new GeoTransform(Translate3D(0,0,depthPositionZ)));
651 physiHECModule->add(physiDepth[iDepth]);
652 depthPositionZ +=depthSize[iDepth]/2.;
658 return physiHECModule;