Fix volume overlaps in tracker frame

DetectorDescription/GeoModel/FaserGeoModel/data/geomDB.sql

@@ -1526,7 +1526,7 @@ CREATE TABLE "SCTBRLMODULE_DATA" ( "SCTBRLMODULE_DATA_ID" SLONGLONG ,"BASEBOARDT
 "BASEBOARDMATERIAL" TEXT ,"BASEBOARDOFFSETY" DOUBLE ,"BASEBOARDOFFSETZ" DOUBLE ,"HYBRIDTHICKNESS" DOUBLE ,"HYBRIDWIDTH" DOUBLE ,"HYBRIDLENGTH" DOUBLE ,
 "HYBRIDMATERIAL" TEXT ,"HYBRIDOFFSETX" DOUBLE ,"HYBRIDOFFSETZ" DOUBLE ,"PIGTAILTHICKNESS" DOUBLE ,"PIGTAILWIDTH" DOUBLE ,"PIGTAILLENGTH" DOUBLE ,
 "PIGTAILMATERIAL" TEXT ,"STEREOUPPERSIGN" INT ,"STEREOANGLE" DOUBLE ,"SENSORTOSENSORGAP" DOUBLE ,"SIDEUPPER" INT , UNIQUE ( "SCTBRLMODULE_DATA_ID" ) );
-INSERT INTO "SCTBRLMODULE_DATA" VALUES(0,0.58,87.6,61.8,'sct::BrlBaseBoard',-5.7,-7.1,0.9,74.6,21.0,'sct::BrlHybrid',1.058,-15.5,0.9,25.4,35.4,'sct::PigTail',-1,40.0,0.6,0);
+INSERT INTO "SCTBRLMODULE_DATA" VALUES(0,0.38,87.2,61.8,'sct::BrlBaseBoard',-5.7,-7.1,0.9,74.6,21.0,'sct::BrlHybrid',1.058,-15.5,0.9,25.4,35.4,'sct::PigTail',-1,40.0,0.6,0);
 DROP TABLE IF EXISTS "SCTBRLMODULE_DATA2TAG";
 CREATE TABLE "SCTBRLMODULE_DATA2TAG" ( "SCTBRLMODULE_TAG_ID" SLONGLONG ,"SCTBRLMODULE_DATA_ID" SLONGLONG  );
 INSERT INTO "SCTBRLMODULE_DATA2TAG" VALUES(107003,0);

Tracker/TrackerDetDescr/FaserSCT_GeoModel/src/SCT_Frame.cxx

@@ -109,7 +109,7 @@ SCT_Frame::build(SCT_Identifier id)
   {
     int izSide = -1 + 2 * side;
     int etaSign = -izSide;
-    GeoTransform* sideTransform = new GeoTransform(GeoTrf::Translate3D(0.0, 0.0, izSide * m_sideHalfPitch) * 
+    GeoTransform* sideTransform = new GeoTransform(GeoTrf::Translate3D(0.0, 0.0, izSide * m_sideHalfPitch ) * 
                                                GeoTrf::RotateY3D(-izSide * 90 * Gaudi::Units::deg));
     for (int module = 0; module < 4; module++)
     {

Tracker/TrackerDetDescr/FaserSCT_GeoModel/src/SCT_Module.cxx

@@ -67,6 +67,7 @@ SCT_Module::~SCT_Module()
 
   delete m_env1RefPointVector;
   delete m_env2RefPointVector;
+  delete m_env3RefPointVector;
 }
 
 
@@ -141,7 +142,7 @@ SCT_Module::preBuild()
   GeoTrf::Vector3D w(0.0, v.y(), m_baseBoardOffsetZ - 0.5*baseBoardLength);
   GeoTrf::Vector3D x(0.0, u.y(),w.z());
   
-  // for corner of hybrid, connectorouter and pigtail of outer side.
+  // for corner of hybrid, connector outer and pigtail of outer side.
   GeoTrf::Vector3D i(0.0, 
                       0.5*outerSideHybridWidth,
                       m_outerSide->hybridOffsetZ() + 0.5*outerSidePigtailLength);
@@ -196,18 +197,28 @@ SCT_Module::preBuild()
 
   const double zmaxEnv1 = std::max(z_ab, z_ef);
   const double zminEnv1 = std::min(z_cd, z_gh);
+  const double zmaxEnv3 = u.z();
+  const double zminEnv3 = w.z();
 
   const double ypre_maxEnv1 = std::max(y_ad, y_eh);
   const double ypre_minEnv1 = std::min(y_bc, y_fg);
 
-  const double ymaxEnv1 = std::max(ypre_maxEnv1, u.y());
-  const double yminEnv1 = std::min(ypre_minEnv1, v.y());
+  // const double ymaxEnv1 = std::max(ypre_maxEnv1, u.y());
+  // const double yminEnv1 = std::min(ypre_minEnv1, v.y());
+  const double ymaxEnv1 = ypre_maxEnv1;
+  const double yminEnv1 = ypre_minEnv1;
+  const double ymaxEnv3 = std::max(ypre_maxEnv1, u.y());
+  const double yminEnv3 = std::min(ypre_minEnv1, v.y());
 
   // some temporary value.
   const double thicknessEnv1 = m_sensorGap + 2.0*m_outerSide->sensor()->thickness();
   const double lengthEnv1 = zmaxEnv1 - zminEnv1;
   const double widthEnv1  = ymaxEnv1 - yminEnv1;
 
+  const double thicknessEnv3 = thicknessEnv1;
+  const double lengthEnv3 = zmaxEnv3 - zminEnv3;
+  const double widthEnv3 = ymaxEnv3 - yminEnv3;
+
   // Center of evnelope1.
   const double xCenterEnv1 = 0.0;
   const double yCenterEnv1 = yminEnv1 + 0.5*widthEnv1;
@@ -215,6 +226,13 @@ SCT_Module::preBuild()
 
   m_env1RefPointVector = new GeoTrf::Vector3D(-xCenterEnv1, -yCenterEnv1, -zCenterEnv1);
 
+  // Center of envelope3
+  const double xCenterEnv3 = 0.0;
+  const double yCenterEnv3 = yminEnv3 + 0.5*widthEnv3;
+  const double zCenterEnv3 = zmaxEnv3 - 0.5*lengthEnv3;
+
+  m_env3RefPointVector = new GeoTrf::Vector3D(-xCenterEnv3, -yCenterEnv3, -zCenterEnv3);
+
   // Calculate demension of envelope2.
   const double z_ikl = std::max(i.z(), l.z());
   const double z_qr = std::max(q.z(), r.z());
@@ -266,6 +284,156 @@ SCT_Module::preBuild()
   const double yCenterSubBox = ymaxSubBox - 0.5*widthSubBox;
   const double zCenterSubBox = zmaxSubBox - 0.5*lengthSubBox;
 
+  // const double xmaxSubBox1a = - 0.5*m_baseBoard->thickness() - m_safety;
+  // const double xminSubBox1a = - 0.5*thicknessEnv2 - 2.0*m_safety;
+
+  // const double yminSubBox1a = std::max(r.y(), s.y()) + m_safety;
+  // const double ymaxSubBox1a = std::min(y_bc, y_fg) - 2.0*m_safety;
+
+  // const double zmaxSubBox1a = z_st - m_safety;
+  // const double zminSubBox1a = zminEnv1 - 2.0*m_safety; 
+  
+  // const double thicknessSubBox1a = xmaxSubBox1a - xminSubBox1a;
+  // const double widthSubBox1a = ymaxSubBox1a - yminSubBox1a;
+  // const double lengthSubBox1a = zmaxSubBox1a - zminSubBox1a;
+
+  // // Center of subbox.
+  // const double xCenterSubBox1a = xmaxSubBox1a - 0.5*thicknessSubBox1a;
+  // const double yCenterSubBox1a = ymaxSubBox1a - 0.5*widthSubBox1a;
+  // const double zCenterSubBox1a = zmaxSubBox1a - 0.5*lengthSubBox1a;
+
+
+  // const double xmaxSubBox1b = xmaxSubBox1a;
+  // const double xminSubBox1b = xminSubBox1a;
+
+  // const double yminSubBox1b = yminSubBox1a;
+  // const double ymaxSubBox1b = ymaxSubBox1a;
+
+  // const double zminSubBox1b = z_qr + m_safety;
+  // const double zmaxSubBox1b = zmaxEnv1 + 2.0*m_safety; 
+  
+  // const double thicknessSubBox1b = xmaxSubBox1b - xminSubBox1b;
+  // const double widthSubBox1b = ymaxSubBox1b - yminSubBox1b;
+  // const double lengthSubBox1b = zmaxSubBox1b - zminSubBox1b;
+
+  // // Center of subbox.
+  // const double xCenterSubBox1b = xmaxSubBox1b - 0.5*thicknessSubBox1b;
+  // const double yCenterSubBox1b = ymaxSubBox1b - 0.5*widthSubBox1b;
+  // const double zCenterSubBox1b = zmaxSubBox1b - 0.5*lengthSubBox1b;
+
+
+// Second subbox
+  const double xmaxSubBox2 = - 0.5*thicknessEnv1 - m_safety;
+  const double xminSubBox2 = xminSubBox;
+
+  const double ymaxSubBox2 = ymaxEnv2 + 2.0*m_safety;
+  const double yminSubBox2 = yminEnv2 - 2.0*m_safety;
+
+  const double zmaxSubBox2 = std::max(z_ab, z_ef) + 2.0*m_safety;
+  const double zminSubBox2 = z_qr + 2.0*m_safety;
+
+  const double thicknessSubBox2 = xmaxSubBox2 - xminSubBox2;
+  const double widthSubBox2 = ymaxSubBox2 - yminSubBox2;
+  const double lengthSubBox2 = zmaxSubBox2 - zminSubBox2;
+
+  const double xCenterSubBox2 = xmaxSubBox2 - 0.5*thicknessSubBox2;
+  const double yCenterSubBox2 = ymaxSubBox2 - 0.5*widthSubBox2;
+  const double zCenterSubBox2 = zmaxSubBox2 - 0.5*lengthSubBox2;
+
+  // Third subbox
+  const double xmaxSubBox3 = xmaxSubBox2;
+  const double xminSubBox3 = xminSubBox2;
+
+  const double ymaxSubBox3 = ymaxSubBox2;
+  const double yminSubBox3 = yminSubBox2;
+
+  const double zmaxSubBox3 = z_st - 2.0*m_safety;
+  const double zminSubBox3 = std::min(z_cd, z_gh) - 2.0*m_safety;
+
+  const double thicknessSubBox3 = xmaxSubBox3 - xminSubBox3;
+  const double widthSubBox3 = ymaxSubBox3 - yminSubBox3;
+  const double lengthSubBox3 = zmaxSubBox3 - zminSubBox3;
+
+  const double xCenterSubBox3 = xmaxSubBox3 - 0.5*thicknessSubBox3;
+  const double yCenterSubBox3 = ymaxSubBox3 - 0.5*widthSubBox3;
+  const double zCenterSubBox3 = zmaxSubBox3 - 0.5*lengthSubBox3;
+
+  // Fourth subbox
+  const double xmaxSubBox4 = - 0.5*m_baseBoard->thickness() - m_safety;
+  const double xminSubBox4 = - 0.5*thicknessEnv2 - 10.0*m_safety;
+
+  const double ymaxSubBox4 = std::min(f.y(), g.y()) - m_safety;
+  const double yminSubBox4 = yminEnv2 - 10.0*m_safety;
+
+  const double zmaxSubBox4 = zmaxEnv1 + 10.0*m_safety;
+  const double zminSubBox4 = std::max(q.z(), r.z()) + 2.0*m_safety; 
+  
+  const double thicknessSubBox4 = xmaxSubBox4 - xminSubBox4;
+  const double widthSubBox4 = ymaxSubBox4 - yminSubBox4;
+  const double lengthSubBox4 = zmaxSubBox4 - zminSubBox4;
+
+  // Center of subbox.
+  const double xCenterSubBox4 = xmaxSubBox4 - 0.5*thicknessSubBox4;
+  const double yCenterSubBox4 = ymaxSubBox4 - 0.5*widthSubBox4;
+  const double zCenterSubBox4 = zmaxSubBox4 - 0.5*lengthSubBox4;
+
+  // Fifth subbox
+  const double xmaxSubBox5 = - 0.5*m_baseBoard->thickness() - m_safety;
+  const double xminSubBox5 = - 0.5*thicknessEnv2 - 10.0*m_safety;
+
+  const double ymaxSubBox5 = std::min(f.y(), g.y()) - m_safety;
+  const double yminSubBox5 = yminEnv2 - 10.0*m_safety;
+
+  const double zminSubBox5 = zminEnv1 - 10.0*m_safety;
+  const double zmaxSubBox5 = std::min(s.z(), t.z()) - 2.0*m_safety; 
+  
+  const double thicknessSubBox5 = xmaxSubBox5 - xminSubBox5;
+  const double widthSubBox5 = ymaxSubBox5 - yminSubBox5;
+  const double lengthSubBox5 = zmaxSubBox5 - zminSubBox5;
+
+  // Center of subbox.
+  const double xCenterSubBox5 = xmaxSubBox5 - 0.5*thicknessSubBox5;
+  const double yCenterSubBox5 = ymaxSubBox5 - 0.5*widthSubBox5;
+  const double zCenterSubBox5 = zmaxSubBox5 - 0.5*lengthSubBox5;
+
+  // Sixth subbox
+  const double xmaxSubBox6 = - 0.5*m_baseBoard->thickness() - m_safety;
+  const double xminSubBox6 = - 0.5*thicknessEnv2 - 10.0*m_safety;
+
+  const double yminSubBox6 = std::max(e.y(), h.y()) + m_safety;
+  const double ymaxSubBox6 = ymaxEnv2 + 10.0*m_safety;
+
+  const double zmaxSubBox6 = zmaxEnv1 + 10.0*m_safety;
+  const double zminSubBox6 = std::max(q.z(), r.z()) + 2.0*m_safety; 
+  
+  const double thicknessSubBox6 = xmaxSubBox6 - xminSubBox6;
+  const double widthSubBox6 = ymaxSubBox6 - yminSubBox6;
+  const double lengthSubBox6 = zmaxSubBox6 - zminSubBox6;
+
+  // Center of subbox.
+  const double xCenterSubBox6 = xmaxSubBox6 - 0.5*thicknessSubBox6;
+  const double yCenterSubBox6 = ymaxSubBox6 - 0.5*widthSubBox6;
+  const double zCenterSubBox6 = zmaxSubBox6 - 0.5*lengthSubBox6;
+
+  // Seventh subbox
+  const double xmaxSubBox7 = - 0.5*m_baseBoard->thickness() - m_safety;
+  const double xminSubBox7 = - 0.5*thicknessEnv2 - 10.0*m_safety;
+
+  const double yminSubBox7 = std::max(e.y(), h.y()) + m_safety;
+  const double ymaxSubBox7 = ymaxEnv2 + 10.0*m_safety;
+
+  const double zminSubBox7 = zminEnv1 - 10.0*m_safety;
+  const double zmaxSubBox7 = std::min(s.z(), t.z()) - 2.0*m_safety; 
+  
+  const double thicknessSubBox7 = xmaxSubBox7 - xminSubBox7;
+  const double widthSubBox7 = ymaxSubBox7 - yminSubBox7;
+  const double lengthSubBox7 = zmaxSubBox7 - zminSubBox7;
+
+  // Center of subbox.
+  const double xCenterSubBox7 = xmaxSubBox7 - 0.5*thicknessSubBox7;
+  const double yCenterSubBox7 = ymaxSubBox7 - 0.5*widthSubBox7;
+  const double zCenterSubBox7 = zmaxSubBox7 - 0.5*lengthSubBox7;
+
 
   m_env1Thickness = thicknessEnv1 + 2*m_safety;
   m_env1Width     = widthEnv1     + 2*m_safety;
@@ -275,6 +443,10 @@ SCT_Module::preBuild()
   m_env2Width     = widthEnv2     + 2*m_safety;
   m_env2Length    = lengthEnv2    + 2*m_safety;
 
+  m_env3Thickness = thicknessEnv3 + 2*m_safety;
+  m_env3Width     = widthEnv3     + 2*m_safety;
+  m_env3Length    = lengthEnv3    + 2*m_safety;
+
   // Envelope 2 defines the overall thickness. NB. The ski assumes the 
   // the envelope "thickness" is centered on x, which it is.
   m_thickness   = m_env2Thickness;
@@ -292,14 +464,32 @@ SCT_Module::preBuild()
   // 6th Feb 2005 D.Naito modified.
   const GeoBox * envelope1 = new GeoBox(0.5*m_env1Thickness, 0.5*m_env1Width, 0.5*m_env1Length);
   const GeoBox * envelope2 = new GeoBox(0.5*m_env2Thickness, 0.5*m_env2Width, 0.5*m_env2Length);
+  const GeoBox * envelope3 = new GeoBox(0.5*m_env3Thickness, 0.5*m_env3Width, 0.5*m_env3Length);
 
   // 8th Aug 2005 S.Mima modified.
-  const GeoBox * subBox = new GeoBox(0.5*thicknessSubBox, 0.5*widthSubBox, 0.6*lengthSubBox);
+  const GeoBox * subBox  = new GeoBox(0.5*thicknessSubBox, 0.5*widthSubBox, 0.6*lengthSubBox);
+  // const GeoBox * subBox1a  = new GeoBox(0.5*thicknessSubBox1a, 0.5*widthSubBox1a, 0.5*lengthSubBox1a);
+  // const GeoBox * subBox1b  = new GeoBox(0.5*thicknessSubBox1b, 0.5*widthSubBox1b, 0.5*lengthSubBox1b);
+  const GeoBox * subBox2 = new GeoBox(0.5*thicknessSubBox2, 0.5*widthSubBox2, 0.5*lengthSubBox2);
+  const GeoBox * subBox3 = new GeoBox(0.5*thicknessSubBox3, 0.5*widthSubBox3, 0.5*lengthSubBox3);
+  const GeoBox * subBox4 = new GeoBox(0.5*thicknessSubBox4, 0.5*widthSubBox4, 0.5*lengthSubBox4);
+  const GeoBox * subBox5 = new GeoBox(0.5*thicknessSubBox5, 0.5*widthSubBox5, 0.5*lengthSubBox5);
+  const GeoBox * subBox6 = new GeoBox(0.5*thicknessSubBox6, 0.5*widthSubBox6, 0.5*lengthSubBox6);
+  const GeoBox * subBox7 = new GeoBox(0.5*thicknessSubBox7, 0.5*widthSubBox7, 0.5*lengthSubBox7);
 
   // In the following, envelope1 and envelope2 are added and SUBBOX is pulled. 
   const GeoShape & moduleEnvelope = (*envelope1 << GeoTrf::Translate3D(xCenterEnv1, yCenterEnv1, zCenterEnv1)).
+    add(*envelope3 << GeoTrf::Translate3D(xCenterEnv3, yCenterEnv3, zCenterEnv3)).
     add(*envelope2 << GeoTrf::Translate3D(xCenterEnv2, yCenterEnv2, zCenterEnv2)).
-    subtract(*subBox << GeoTrf::Translate3D(xCenterSubBox, yCenterSubBox, zCenterSubBox));
+    subtract(*subBox4 << GeoTrf::Translate3D(xCenterSubBox4, yCenterSubBox4, zCenterSubBox4)).
+    subtract(*subBox5 << GeoTrf::Translate3D(xCenterSubBox5, yCenterSubBox5, zCenterSubBox5)).
+    subtract(*subBox6 << GeoTrf::Translate3D(xCenterSubBox6, yCenterSubBox6, zCenterSubBox6)).
+    subtract(*subBox7 << GeoTrf::Translate3D(xCenterSubBox7, yCenterSubBox7, zCenterSubBox7)).
+    subtract(*subBox << GeoTrf::Translate3D(xCenterSubBox, yCenterSubBox, zCenterSubBox)).
+    subtract(*subBox2 << GeoTrf::Translate3D(xCenterSubBox2, yCenterSubBox2, zCenterSubBox2)).
+    subtract(*subBox3 << GeoTrf::Translate3D(xCenterSubBox3, yCenterSubBox3, zCenterSubBox3));
+    // subtract(*subBox1a << GeoTrf::Translate3D(xCenterSubBox1a, yCenterSubBox1a, zCenterSubBox1a)).
+    // subtract(*subBox1b << GeoTrf::Translate3D(xCenterSubBox1b, yCenterSubBox1b, zCenterSubBox1b)).
 
   const GeoLogVol * moduleLog           = new GeoLogVol(getName(), &moduleEnvelope, m_materials->gasMaterial());
   

Tracker/TrackerDetDescr/FaserSCT_GeoModel/src/SCT_Module.h

@@ -50,6 +50,7 @@ public:
 
   const GeoTrf::Vector3D * env1RefPointVector() const {return m_env1RefPointVector;}
   const GeoTrf::Vector3D * env2RefPointVector() const {return m_env2RefPointVector;}
+  const GeoTrf::Vector3D * env3RefPointVector() const {return m_env3RefPointVector;}
 
   double sensorGap()    const {return m_sensorGap;}
   double stereoInner()  const {return m_stereoInner;}
@@ -80,6 +81,9 @@ private:
   double m_env2Thickness;
   double m_env2Width;
   double m_env2Length;
+  double m_env3Thickness;
+  double m_env3Width;
+  double m_env3Length;
 
   double m_activeWidth;
 
@@ -105,6 +109,7 @@ private:
 
   GeoTrf::Vector3D * m_env1RefPointVector;
   GeoTrf::Vector3D * m_env2RefPointVector;
+  GeoTrf::Vector3D * m_env3RefPointVector;
 
 };