#include <DDTIDModuleAlgo.h>

Public Member Functions
	DDTIDModuleAlgo ()
void	execute (DDCompactView &cpv)
void	initialize (const DDNumericArguments &nArgs, const DDVectorArguments &vArgs, const DDMapArguments &mArgs, const DDStringArguments &sArgs, const DDStringVectorArguments &vsArgs)
virtual	~DDTIDModuleAlgo ()
Private Attributes
double	activeHeight
std::string	activeMat
std::vector< std::string >	activeName
std::string	activeRot
std::vector< double >	backplaneThick
double	bottomFrameHeight
double	bottomFrameOver
double	boxFrameHeight
std::string	boxFrameMat
std::string	boxFrameName
double	boxFrameThick
double	boxFrameWidth
double	coolHeight
std::string	coolMat
std::string	coolName
double	coolThick
double	coolWidth
int	detectorN
double	detTilt
double	dlBottom
double	dlHybrid
double	dlTop
bool	doComponents
double	fullHeight
std::string	genMat
std::vector< std::string >	holeFrameName
std::vector< std::string >	holeFrameRot
std::vector< std::string >	holeKaptonName
std::vector< std::string >	holeKaptonRot
double	hybridHeight
std::string	hybridMat
std::string	hybridName
double	hybridThick
double	hybridWidth
std::string	kaptonMat
std::vector< std::string >	kaptonName
double	kaptonOver
double	kaptonThick
double	moduleThick
double	pitchHeight
std::string	pitchMat
std::vector< std::string >	pitchName
double	pitchStereoTol
double	pitchThick
std::string	sideFrameMat
std::vector< std::string >	sideFrameName
double	sideFrameOver
double	sideFrameThick
double	sideFrameWidth
double	sideWidthBottom
double	sideWidthTop
double	topFrameHeight
double	topFrameOver
std::string	waferMat
std::vector< std::string >	waferName
std::vector< double >	waferThick

Detailed Description

Definition at line 10 of file DDTIDModuleAlgo.h.

Constructor & Destructor Documentation

DDTIDModuleAlgo::DDTIDModuleAlgo ( )

Definition at line 19 of file DDTIDModuleAlgo.cc.

References LogDebug.

                                 {
  LogDebug("TIDGeom") << "DDTIDModuleAlgo info: Creating an instance";
}

DDTIDModuleAlgo::~DDTIDModuleAlgo ( ) [virtual]

Definition at line 23 of file DDTIDModuleAlgo.cc.

{}

Member Function Documentation

void DDTIDModuleAlgo::execute ( DDCompactView & cpv )

Definition at line 157 of file DDTIDModuleAlgo.cc.

References activeHeight, activeMat, activeName, activeRot, backplaneThick, bottomFrameHeight, bottomFrameOver, DDSolidFactory::box(), boxFrameHeight, boxFrameMat, boxFrameName, boxFrameThick, boxFrameWidth, coolHeight, coolMat, coolName, coolThick, coolWidth, funct::cos(), DDBase< N, C >::ddname(), DDSplit(), detectorN, detTilt, dlBottom, dlHybrid, dlTop, doComponents, first, fullHeight, genMat, holeFrameName, holeFrameRot, holeKaptonName, holeKaptonRot, hybridHeight, hybridMat, hybridName, hybridThick, hybridWidth, gen::k, kaptonMat, kaptonName, kaptonOver, kaptonThick, LogDebug, module(), moduleThick, mergeVDriftHistosByStation::name, DDBase< N, C >::name(), dbtoconf::parent, pitchHeight, pitchMat, pitchName, pitchStereoTol, pitchThick, DDCompactView::position(), edm::second(), sideFrameMat, sideFrameName, sideFrameOver, sideFrameThick, sideFrameWidth, sideWidthBottom, sideWidthTop, funct::sin(), DDSolidFactory::subtraction(), topFrameHeight, topFrameOver, DDSolidFactory::trap(), waferMat, waferName, and waferThick.

                                                {
  
  LogDebug("TIDGeom") << "==>> Constructing DDTIDModuleAlgo...";

  DDName parentName = parent().name(); 
  DDName name;

  double sidfr = sideFrameWidth - sideFrameOver;      // width of side frame on the sides of module 
  double botfr;                                       // width of side frame at the the bottom of the modules 
  double topfr;                                       // width of side frame at the the top of the modules 
  double kaptonHeight; 
  if (dlHybrid > dlTop) {
    // ring 1, ring 2
    topfr = topFrameHeight - pitchHeight - topFrameOver;      
    botfr = bottomFrameHeight - bottomFrameOver; 
    kaptonHeight = fullHeight + botfr;
  } else {
    // ring 3
    topfr = topFrameHeight - topFrameOver;      
    botfr = bottomFrameHeight - bottomFrameOver - pitchHeight; 
    kaptonHeight = fullHeight + topfr;
  }

  double sideFrameHeight = fullHeight + pitchHeight + botfr + topfr; 
  double kaptonWidth = sidfr + kaptonOver;

  double  dxbot = 0.5*dlBottom + sidfr;
  double  dxtop = 0.5*dlTop + sidfr;
  double  dxtopenv, dxbotenv;           // top/bot width of the module envelope trap

  // Envelope 
  if (dlHybrid > dlTop) {
    // ring 1, ring 2
    dxtopenv = dxbot + (dxtop-dxbot)*(fullHeight+pitchHeight+topfr+hybridHeight)/fullHeight;
    dxbotenv = dxtop - (dxtop-dxbot)*(fullHeight+botfr)/fullHeight;
  } else {
    // ring 3
    dxtopenv = dxbot + (dxtop-dxbot)*(fullHeight+topfr)/fullHeight;
    dxbotenv = dxbot;
  }
  double bl1   = dxbotenv;
  double bl2   = dxtopenv;
  double h1    = 0.5 * moduleThick;
  double dz    = 0.5 * (boxFrameHeight + sideFrameHeight);

  DDSolid solidUncut, solidCut;
  DDSolid    solid = DDSolidFactory::trap(parentName, dz, 0, 0,
                                          h1, bl1, bl1, 0, h1, bl2, bl2, 0);
  DDName     matname = DDName(DDSplit(genMat).first, DDSplit(genMat).second);
  DDMaterial matter  = DDMaterial(matname);
  DDLogicalPart module(solid.ddname(), matter, solid);
  LogDebug("TIDGeom") << "DDTIDModuleAlgo test:\t" << solid.name() 
                      << " Trap made of " << genMat << " of dimensions " << dz 
                      << ", 0, 0, " << h1  << ", " << bl1 << ", " << bl1 
                      << ", 0, " << h1 << ", " << bl2  << ", " << bl2 
                      << ", 0";

  if (doComponents) {

    //Box frame
    name    = DDName(DDSplit(boxFrameName).first,DDSplit(boxFrameName).second);
    matname = DDName(DDSplit(boxFrameMat).first, DDSplit(boxFrameMat).second);
    matter  = DDMaterial(matname);
    double dx = 0.5 * boxFrameWidth;
    double dy = 0.5 * boxFrameThick;
    double dz = 0.5 * boxFrameHeight; 
    solid = DDSolidFactory::box(name, dx, dy, dz);
    LogDebug("TIDGeom") << "DDTIDModuleAlgo test:\t" << solid.name() 
                        << " Box made of " << matname << " of dimensions " 
                        << dx << ", " << dy << ", " << dz;
    DDLogicalPart boxFrame(solid.ddname(), matter, solid);


    // Hybrid
    name    = DDName(DDSplit(hybridName).first, DDSplit(hybridName).second);
    matname = DDName(DDSplit(hybridMat).first, DDSplit(hybridMat).second);
    matter  = DDMaterial(matname);
    dx = 0.5 * hybridWidth;
    dy = 0.5 * hybridThick;
    dz        = 0.5 * hybridHeight;
    solid = DDSolidFactory::box(name, dx, dy, dz);
    LogDebug("TIDGeom") << "DDTIDModuleAlgo test:\t" << solid.name() 
                        << " Box made of " << matname << " of dimensions " 
                        << dx << ", " << dy << ", " << dz;
    DDLogicalPart hybrid(solid.ddname(), matter, solid);

    // Cool Insert
    name    = DDName(DDSplit(coolName).first, DDSplit(coolName).second);
    matname = DDName(DDSplit(coolMat).first, DDSplit(coolMat).second);
    matter  = DDMaterial(matname);
    dx = 0.5 * coolWidth;
    dy = 0.5 * coolThick;
    dz        = 0.5 * coolHeight;
    solid = DDSolidFactory::box(name, dx, dy, dz);
    LogDebug("TIDGeom") << "DDTIDModuleAlgo test:\t" << solid.name() 
                        << " Box made of " << matname << " of dimensions " 
                        << dx << ", " << dy << ", " << dz;
    DDLogicalPart cool(solid.ddname(), matter, solid);

    // Loop over detectors to be placed
    for (int k = 0; k < detectorN; k++) {

      double bbl1, bbl2; // perhaps useless (bl1 enough)

      // Frame Sides
      name    = DDName(DDSplit(sideFrameName[k]).first,
                       DDSplit(sideFrameName[k]).second);
      matname = DDName(DDSplit(sideFrameMat).first,
                       DDSplit(sideFrameMat).second);
      matter  = DDMaterial(matname);
      if (dlHybrid > dlTop) {
        // ring 1, ring 2
        bbl1 = dxtop - (dxtop-dxbot)*(fullHeight+botfr)/fullHeight;
        bbl2 = dxbot + (dxtop-dxbot)*(fullHeight+pitchHeight+topfr)/fullHeight;
      } else {
        // ring 3
        bbl1 = dxtop - (dxtop-dxbot)*(fullHeight+pitchHeight+botfr)/fullHeight;
        bbl2 = dxbot + (dxtop-dxbot)*(fullHeight+topfr)/fullHeight;
      }
      h1 = 0.5 * sideFrameThick;
      dz = 0.5 * sideFrameHeight;
      solid = DDSolidFactory::trap(name, dz, 0, 0, h1, bbl1, bbl1, 0, 
                                   h1,  bbl2, bbl2, 0);
      LogDebug("TIDGeom") << "DDTIDModuleAlgo test:\t" << solid.name() 
                          << " Trap made of " << matname << " of dimensions "
                          << dz << ", 0, 0, " << h1 << ", " << bbl1 << ", " 
                          << bbl1 << ", 0, " << h1 << ", " << bbl2 << ", " 
                          << bbl2 << ", 0";
      DDLogicalPart sideFrame(solid.ddname(), matter, solid);

      std::string rotstr, rotns; 
      DDRotation rot;

      // Hole in the frame below the wafer 
      name    = DDName(DDSplit(holeFrameName[k]).first,
                       DDSplit(holeFrameName[k]).second);
      matname = DDName(DDSplit(genMat).first, DDSplit(genMat).second);
      matter  = DDMaterial(matname);
      double xpos, zpos;
      dz        = fullHeight - bottomFrameOver - topFrameOver;
      bbl1     = dxbot - sideFrameWidth + bottomFrameOver*(dxtop-dxbot)/fullHeight;
      bbl2     = dxtop - sideFrameWidth - topFrameOver*(dxtop-dxbot)/fullHeight;
      if (dlHybrid > dlTop) {
        // ring 1, ring 2
        zpos    = -(topFrameHeight+0.5*dz-0.5*sideFrameHeight);
      } else {
        // ring 3
        zpos    = bottomFrameHeight+0.5*dz-0.5*sideFrameHeight;
      }
      dz     /= 2.;
      solid = DDSolidFactory::trap(name, dz, 0,0, h1,bbl1,bbl1, 0, 
                                   h1,bbl2,bbl2, 0);
      LogDebug("TIDGeom") << "DDTIDModuleAlgo test:\t" << solid.name() 
                          << " Trap made of " << matname << " of dimensions "
                          << dz << ", 0, 0, " << h1 << ", " << bbl1 << ", " 
                          << bbl1 << ", 0, " << h1 << ", " << bbl2 << ", " 
                          << bbl2 << ", 0";
      DDLogicalPart holeFrame(solid.ddname(), matter, solid);      

      rotstr = DDSplit(holeFrameRot[k]).first;
      if (rotstr != "NULL") {
        rotns = DDSplit(holeFrameRot[k]).second;
        rot   = DDRotation(DDName(rotstr, rotns));      
      } else {
        rot     = DDRotation();
      }
     cpv.position(holeFrame, sideFrame, 1, DDTranslation(0.0, 0.0, zpos), rot );   
      LogDebug("TIDGeom") << "DDTIDModuleAlgo test: " << holeFrame.name() 
                          << " number 1 positioned in " << sideFrame.name()
                          << " at (0,0," << zpos << ") with no rotation";

      // Kapton circuit
      //  name = DDName(DDSplit(kaptonName[k]).first,DDSplit(kaptonName[k]).second);
      matname = DDName(DDSplit(kaptonMat).first,DDSplit(kaptonMat).second);
      matter  = DDMaterial(matname);
      double kaptonExtraHeight=0;      // kapton extra height in the stereo
      if (dlHybrid > dlTop) {
        // ring 1, ring 2
        bbl1 = dxtop - (dxtop-dxbot)*(fullHeight+botfr)/fullHeight;
        if ( k == 1 ) {
          kaptonExtraHeight = dlTop*sin(detTilt)-fullHeight*(1-cos(detTilt));
          kaptonExtraHeight = 0.5*fabs(kaptonExtraHeight);
          bbl2 = dxbot + (dxtop-dxbot)*(fullHeight+kaptonExtraHeight)/fullHeight;
        }
        else {
          bbl2 = dxtop;
        }
      } else {
        // ring 3
        bbl2 = dxbot + (dxtop-dxbot)*(fullHeight+topfr)/fullHeight;
        if ( k == 1) {
          kaptonExtraHeight = dlBottom*sin(detTilt)-fullHeight*(1-cos(detTilt));
          kaptonExtraHeight = 0.5*fabs(kaptonExtraHeight);
          bbl1 = dxtop - (dxtop-dxbot)*(fullHeight+kaptonExtraHeight)/fullHeight;
        }  else {
          bbl1 = dxbot;
        }
      }
      h1 = 0.5 * kaptonThick;
      dz = 0.5 * (kaptonHeight+kaptonExtraHeight);

      // For the stereo create the uncut solid, the solid to be removed and then the subtraction solid
      if ( k == 1 ) {
        // Uncut solid
        std::string kaptonUncutName=kaptonName[k]+"Uncut";
        name    = DDName(DDSplit(kaptonUncutName).first,
                         DDSplit(kaptonUncutName).second);
        solidUncut = DDSolidFactory::trap(name, dz, 0, 0, h1, bbl1, bbl1, 0,
                                          h1,  bbl2, bbl2, 0);

        // Piece to be cut
        std::string kaptonCutName=kaptonName[k]+"Cut";
        name    = DDName(DDSplit(kaptonCutName).first,
                         DDSplit(kaptonCutName).second);         

        if (dlHybrid > dlTop) {
          dz   = 0.5 * dlTop;
        } else {
          dz   = 0.5 * dlBottom;
        }
        h1      = 0.5 * kaptonThick;
        bbl1     =  fabs(dz*sin(detTilt));
        bbl2     =  bbl1*0.000001;
        double thet = atan((bbl1-bbl2)/(2*dz)); 
        solidCut  = DDSolidFactory::trap(name, dz, thet, 0, h1, bbl1, bbl1, 0,
                                         h1, bbl2, bbl2, 0);

        std::string aRot("tidmodpar:9PYX"); 
        rotstr  = DDSplit(aRot).first;
        rotns = DDSplit(aRot).second;
        rot   = DDRotation(DDName(rotstr, rotns));

        xpos = -0.5 * fullHeight * sin(detTilt);
        zpos = 0.5 * kaptonHeight - bbl2;

        // Subtraction Solid
        name   = DDName(DDSplit(kaptonName[k]).first,
                        DDSplit(kaptonName[k]).second);  
        solid  = DDSolidFactory::subtraction(name, solidUncut, solidCut, 
                                             DDTranslation(xpos,0.0,zpos),rot);
      } else {
        name   = DDName(DDSplit(kaptonName[k]).first,
                        DDSplit(kaptonName[k]).second);
        solid  = DDSolidFactory::trap(name, dz, 0, 0, h1, bbl1, bbl1, 0, 
                                      h1,  bbl2, bbl2, 0);
      }

      DDLogicalPart kapton(solid.ddname(), matter, solid);         
      LogDebug("TIDGeom") << "DDTIDModuleAlgo test:\t" << solid.name() 
                          << " SUBTRACTION SOLID Trap made of " << matname 
                          << " of dimensions " << dz << ", 0, 0, " << h1 
                          << ", " << bbl1 << ", " << bbl1 << ", 0, " << h1 
                          << ", " << bbl2 << ", " << bbl2 << ", 0";


      // Hole in the kapton below the wafer 
      name    = DDName(DDSplit(holeKaptonName[k]).first,
                       DDSplit(holeKaptonName[k]).second);
      matname = DDName(DDSplit(genMat).first, DDSplit(genMat).second);
      matter  = DDMaterial(matname);
      dz      = fullHeight - kaptonOver;
      xpos = 0; 
      if (dlHybrid > dlTop) {
        // ring 1, ring 2
        bbl1 = dxbot - kaptonWidth + kaptonOver*(dxtop-dxbot)/fullHeight;
        bbl2 = dxtop - kaptonWidth;
        zpos = 0.5*(kaptonHeight-kaptonExtraHeight-dz); 
        if ( k == 1 ) {
          zpos -= 0.5*kaptonOver*(1-cos(detTilt));
          xpos = -0.5*kaptonOver*sin(detTilt); 
        }
      } else {
        // ring 3
        bbl1 = dxbot - kaptonWidth;
        bbl2 = dxtop - kaptonWidth - kaptonOver*(dxtop-dxbot)/fullHeight;
        zpos = -0.5*(kaptonHeight-kaptonExtraHeight-dz);
      }
      dz     /= 2.;
      solid = DDSolidFactory::trap(name, dz, 0,0, h1,bbl1,bbl1, 0, 
                                   h1,bbl2,bbl2, 0);
      LogDebug("TIDGeom") << "DDTIDModuleAlgo test:\t" << solid.name() 
                          << " Trap made of " << matname << " of dimensions "
                          << dz << ", 0, 0, " << h1 << ", " << bbl1 << ", " 
                          << bbl1 << ", 0, " << h1 << ", " << bbl2 << ", " 
                          << bbl2 << ", 0";
      DDLogicalPart holeKapton(solid.ddname(), matter, solid);      

      rotstr = DDSplit(holeKaptonRot[k]).first;
      if (rotstr != "NULL") {
        rotns = DDSplit(holeKaptonRot[k]).second;
        rot   = DDRotation(DDName(rotstr, rotns));      
      } else {
        rot     = DDRotation();
      }
     cpv.position(holeKapton, kapton, 1, DDTranslation(xpos, 0.0, zpos), rot );   
      LogDebug("TIDGeom") << "DDTIDModuleAlgo test: " << holeKapton.name() 
                          << " number 1 positioned in " << kapton.name()
                          << " at (0,0," << zpos << ") with no rotation";



      // Wafer
      name    = DDName(DDSplit(waferName[k]).first,
                       DDSplit(waferName[k]).second);
      matname = DDName(DDSplit(waferMat).first, DDSplit(waferMat).second);
      matter  = DDMaterial(matname);
      if (k == 0 && dlHybrid < dlTop) {
        bl1     = 0.5 * dlTop;
        bl2     = 0.5 * dlBottom;
      } else {
        bl1     = 0.5 * dlBottom;
        bl2     = 0.5 * dlTop;
      }
      h1      = 0.5 * waferThick[k];
      dz      = 0.5 * fullHeight;
      solid = DDSolidFactory::trap(name, dz, 0,0, h1,bl1,bl1,0, h1,bl2,bl2,0);
      LogDebug("TIDGeom") << "DDTIDModuleAlgo test:\t" << solid.name() 
                          << " Trap made of " << matname << " of dimensions "
                          << dz << ", 0, 0, " << h1 << ", " << bl1 << ", " 
                          << bl1 << ", 0, " << h1 << ", " << bl2 << ", "
                          << bl2 << ", 0";
      DDLogicalPart wafer(solid.ddname(), matter, solid);

      // Active
      name    = DDName(DDSplit(activeName[k]).first,
                       DDSplit(activeName[k]).second);
      matname = DDName(DDSplit(activeMat).first, DDSplit(activeMat).second);
      matter  = DDMaterial(matname);
      if (k == 0 && dlHybrid < dlTop) {
        bl1    -= sideWidthTop;
        bl2    -= sideWidthBottom;
      }
      else {
        bl1    -= sideWidthBottom;
        bl2    -= sideWidthTop;
      }
      dz      = 0.5 * (waferThick[k] - backplaneThick[k]); // inactive backplane
      h1      = 0.5 * activeHeight;
      solid = DDSolidFactory::trap(name, dz, 0,0, h1,bl2,bl1,0, h1,bl2,bl1,0);
      LogDebug("TIDGeom") << "DDTIDModuleAlgo test:\t" << solid.name() 
                          << " Trap made of " << matname << " of dimensions "
                          << dz << ", 0, 0, " << h1 << ", " << bl2 << ", " 
                          << bl1 << ", 0, " << h1 << ", " << bl2 << ", "
                          << bl1 << ", 0";
      DDLogicalPart active(solid.ddname(), matter, solid);
      rotstr = DDSplit(activeRot).first;
      if (rotstr != "NULL") {
        rotns = DDSplit(activeRot).second;
        rot   = DDRotation(DDName(rotstr, rotns));
      } else {
        rot     = DDRotation();
      }
      DDTranslation tran(0.0,-0.5 * backplaneThick[k],0.0); // from the definition of the wafer local axes
     cpv.position(active, wafer, 1, tran, rot);  // inactive backplane
      LogDebug("TIDGeom") << "DDTIDModuleAlgo test: " << active.name() 
                          << " number 1 positioned in " << wafer.name() 
                          << " at " << tran << " with " << rot;
      
      //Pitch Adapter
      name    = DDName(DDSplit(pitchName[k]).first,
                       DDSplit(pitchName[k]).second);
      matname = DDName(DDSplit(pitchMat).first, DDSplit(pitchMat).second);
      matter  = DDMaterial(matname);
      if (dlHybrid > dlTop) {
        dz   = 0.5 * dlTop;
      } else {
        dz   = 0.5 * dlBottom;
      }
      if (k == 0) {
        dx      = dz;
        dy      = 0.5 * pitchThick;
        dz      = 0.5 * pitchHeight;
        solid   = DDSolidFactory::box(name, dx, dy, dz);
        LogDebug("TIDGeom") << "DDTIDModuleAlgo test:\t" << solid.name()
                            << " Box made of " << matname << " of dimensions"
                            << " " << dx << ", " << dy << ", " << dz;
      } else {
        h1      = 0.5 * pitchThick;
        bl1     = 0.5 * pitchHeight + 0.5 * dz * sin(detTilt);
        bl2     = 0.5 * pitchHeight - 0.5 * dz * sin(detTilt);

        dz -=0.5*pitchStereoTol;
        bl1-=pitchStereoTol;
        bl2-=pitchStereoTol;

        double thet = atan((bl1-bl2)/(2.*dz));
        solid   = DDSolidFactory::trap(name, dz, thet, 0, h1, bl1, bl1, 0, 
                                       h1, bl2, bl2, 0);
        LogDebug("TIDGeom") << "DDTIDModuleAlgo test:\t" << solid.name() 
                            << " Trap made of " << matname << " of "
                            << "dimensions " << dz << ", " << thet/CLHEP::deg 
                            << ", 0, " << h1 << ", " << bl1 << ", " << bl1 
                            << ", 0, " << h1 << ", " << bl2 << ", " << bl2 
                            << ", 0";
      }
      DDLogicalPart pa(solid.ddname(), matter, solid);
    }
  }
  LogDebug("TIDGeom") << "<<== End of DDTIDModuleAlgo construction ...";
}

void DDTIDModuleAlgo::initialize	(	const DDNumericArguments &	nArgs,
		const DDVectorArguments &	vArgs,
		const DDMapArguments &	mArgs,
		const DDStringArguments &	sArgs,
		const DDStringVectorArguments &	vsArgs
	)

Definition at line 25 of file DDTIDModuleAlgo.cc.

References activeHeight, activeMat, activeName, activeRot, backplaneThick, bottomFrameHeight, bottomFrameOver, boxFrameHeight, boxFrameMat, boxFrameName, boxFrameThick, boxFrameWidth, coolHeight, coolMat, coolName, coolThick, coolWidth, detectorN, detTilt, dlBottom, dlHybrid, dlTop, doComponents, fullHeight, genMat, holeFrameName, holeFrameRot, holeKaptonName, holeKaptonRot, hybridHeight, hybridMat, hybridName, hybridThick, hybridWidth, i, kaptonMat, kaptonName, kaptonOver, kaptonThick, LogDebug, moduleThick, dbtoconf::parent, pitchHeight, pitchMat, pitchName, pitchStereoTol, pitchThick, sideFrameMat, sideFrameName, sideFrameOver, sideFrameThick, sideFrameWidth, sideWidthBottom, sideWidthTop, topFrameHeight, topFrameOver, waferMat, waferName, and waferThick.

                                                                         {

  int i;
  genMat       = sArgs["GeneralMaterial"];
  detectorN    = (int)(nArgs["DetectorNumber"]);
  DDName parentName = parent().name(); 

  LogDebug("TIDGeom") << "DDTIDModuleAlgo debug: Parent " << parentName 
                      << " General Material " << genMat 
                      << " Detector Planes " << detectorN;

  moduleThick       = nArgs["ModuleThick"];
  detTilt           = nArgs["DetTilt"];
  fullHeight        = nArgs["FullHeight"];
  dlTop             = nArgs["DlTop"];
  dlBottom          = nArgs["DlBottom"];
  dlHybrid          = nArgs["DlHybrid"];
  std::string comp  = sArgs["DoComponents"];
  if (comp == "No" || comp == "NO" || comp == "no") doComponents = false;
  else                                              doComponents = true;

  LogDebug("TIDGeom") << "DDTIDModuleAlgo debug: ModuleThick " 
                      << moduleThick << " Detector Tilt " << detTilt/CLHEP::deg
                      << " Height " << fullHeight << " dl(Top) " << dlTop
                      << " dl(Bottom) " << dlBottom << " dl(Hybrid) "
                      << dlHybrid << " doComponents " << doComponents;

  boxFrameName      = sArgs["BoxFrameName"];
  boxFrameMat       = sArgs["BoxFrameMaterial"];
  boxFrameThick     = nArgs["BoxFrameThick"];
  boxFrameHeight    = nArgs["BoxFrameHeight"];
  boxFrameWidth     = nArgs["BoxFrameWidth"];
  bottomFrameHeight = nArgs["BottomFrameHeight"];
  bottomFrameOver   = nArgs["BottomFrameOver"];
  LogDebug("TIDGeom") << "DDTIDModuleAlgo debug: " << boxFrameName 
                      << " Material " << boxFrameMat << " Thickness " 
                      << boxFrameThick << " width " << boxFrameWidth 
                      <<  " height " << boxFrameHeight
                      << " Extra Height at Bottom " << bottomFrameHeight 
                      << " Overlap " << bottomFrameOver;

  topFrameHeight    = nArgs["TopFrameHeight"];
  topFrameOver      = nArgs["TopFrameOver"];
  sideFrameName     = vsArgs["SideFrameName"];
  sideFrameMat      = sArgs["SideFrameMaterial"];
  sideFrameWidth    = nArgs["SideFrameWidth"];
  sideFrameThick    = nArgs["SideFrameThick"];
  sideFrameOver     = nArgs["SideFrameOver"];
  holeFrameName     = vsArgs["HoleFrameName"];
  holeFrameRot      = vsArgs["HoleFrameRotation"];
  for (i = 0; i < detectorN; i++)
    LogDebug("TIDGeom") << "DDTIDModuleAlgo debug : " << sideFrameName[i] 
                        << " Material " << sideFrameMat << " Width " 
                        << sideFrameWidth << " Thickness " << sideFrameThick
                        << " Overlap " << sideFrameOver << " Hole  "
                        << holeFrameName[i];

  kaptonName     = vsArgs["KaptonName"];
  kaptonMat      = sArgs["KaptonMaterial"];
  kaptonThick    = nArgs["KaptonThick"];
  kaptonOver     = nArgs["KaptonOver"];
  holeKaptonName     = vsArgs["HoleKaptonName"];
  holeKaptonRot      = vsArgs["HoleKaptonRotation"];
  for (i = 0; i < detectorN; i++)
    LogDebug("TIDGeom") << "DDTIDModuleAlgo debug : " << kaptonName[i] 
                        << " Material " << kaptonMat 
                        << " Thickness " << kaptonThick
                        << " Overlap " << kaptonOver << " Hole  "
                        << holeKaptonName[i];


  waferName         = vsArgs["WaferName"];
  waferMat          = sArgs["WaferMaterial"];
  sideWidthTop      = nArgs["SideWidthTop"];
  sideWidthBottom   = nArgs["SideWidthBottom"];

  LogDebug("TIDGeom") << "DDTIDModuleAlgo debug: Wafer Material " 
                      << waferMat  << " Side Width Top " << sideWidthTop
                      << " Side Width Bottom " << sideWidthBottom;
  for (i = 0; i < detectorN; i++)
    LogDebug("TIDGeom") << "\twaferName[" << i << "] = " << waferName[i];

  activeName        = vsArgs["ActiveName"];
  activeMat         = sArgs["ActiveMaterial"];
  activeHeight      = nArgs["ActiveHeight"];
  waferThick        = vArgs["WaferThick"];
  activeRot         = sArgs["ActiveRotation"];
  backplaneThick    = vArgs["BackPlaneThick"];
  LogDebug("TIDGeom") << "DDTIDModuleAlgo debug: Active Material " 
                      << activeMat << " Height " << activeHeight 
                      << " rotated by " << activeRot;
  for (i = 0; i < detectorN; i++)
    LogDebug("TIDGeom") << " translated by (0," << -0.5*backplaneThick[i] 
                        << ",0)\tactiveName[" << i << "] = " << activeName[i]
                        << " of thickness " << waferThick[i]-backplaneThick[i];
  
  hybridName        = sArgs["HybridName"];
  hybridMat         = sArgs["HybridMaterial"];
  hybridHeight      = nArgs["HybridHeight"];
  hybridWidth       = nArgs["HybridWidth"];
  hybridThick       = nArgs["HybridThick"];
  LogDebug("TIDGeom") << "DDTIDModuleAlgo debug: " << hybridName 
                      << " Material " << hybridMat << " Height " 
                      << hybridHeight << " Width " << hybridWidth 
                      << " Thickness " << hybridThick;

  pitchName         = vsArgs["PitchName"];
  pitchMat          = sArgs["PitchMaterial"];
  pitchHeight       = nArgs["PitchHeight"];
  pitchThick        = nArgs["PitchThick"];
  pitchStereoTol    = nArgs["PitchStereoTolerance"];

  LogDebug("TIDGeom") << "DDTIDModuleAlgo debug: Pitch Adapter Material "
                      << pitchMat << " Height " << pitchHeight
                      << " Thickness " << pitchThick;
  for (i = 0; i < detectorN; i++)
    LogDebug("TIDGeom") <<  "\tpitchName[" << i << "] = " << pitchName[i];

  coolName         = sArgs["CoolInsertName"];
  coolMat          = sArgs["CoolInsertMaterial"];
  coolHeight       = nArgs["CoolInsertHeight"];
  coolThick        = nArgs["CoolInsertThick"];
  coolWidth        = nArgs["CoolInsertWidth"];
  LogDebug("TIDGeom") << "DDTIDModuleAlgo debug: Cool Element Material "
                      << coolMat << " Height " << coolHeight
                      << " Thickness " << coolThick << " Width " << coolWidth;
}