#ifdef BAF
df << "#dirdef SCT" << endl;
df << "#open   SCT" << endl;

df << "#dirdef Barrel" << endl;
df << "#open   Barrel" << endl;
#endif


  // We're going to read those parameters which interest
  // us from the preXml file, and then produce the 
  // relevant output.
  // The xml file comes to us as the element called doc.

  // Since there' are potential name clashes everywhere, let's
  // restrict ourselves to looking in only that part of the preXml file
  // which is relevant to the SCT barrel and this particular geometry.

  

  // These are some macros that save a bit of typing.
  // All they do is read values from the preXml file
  // and store them in constants and const vectors.
  // They make use of the fact that I have the same
  // names for my variables both in this program AND
  // in the preXml file.  You don't have to do it
  // this way if you don't want to.  By way of example,
  // I've typed the first "read" in it's expanded form.

#define DWSET(t,v)                                            \
  preXml:: t v ;                                              \
  useMy.fill( v , #v );                                       \
  cout << "I found "<< #v  <<" = "<< v << endl;

#define DWSETARRAY(t,v,n)                                     \
  vector< preXml:: t > v ( n ) ;                              \
  useMy.fill( v , #v ) ;                                      \
  {                                                           \
    for(int i=0; i< n ;i++) {                                 \
      cout << "I found "<< #v <<"["<<i<<"] = "<< v[i] <<endl; \
    }                                                         \
  };

  // -----------------------------------------------------
  // -------- Some SCT-Barrel specific quantites ---------
  // -------- (close to old AGE structure)       --------- 
  // -----------------------------------------------------

  // The first DWSET which follows would look like this if expanded:
  //
  // preXml::Length rMin;
  // man.fill(rMin, "rMin");
  // cout << "I found rMin = " << rMin << endl;

  DWSET(Length,  rMin)     //  overall min radius
  DWSET(Length,  rMax)     //  overall max radius
  DWSET(Length,  hLen)     //  overall half length
  DWSET(Integer, nLay)     //  Number of Layers
  DWSET(Length,  dYSect)   //  Width of a ski
  DWSET(Number,  rTckEle)  //  Thickness of the Electronics (in rad.lens.)
  DWSET(Number,  rTckLum)  //  THICKNESS OF THE LUMP (in % of r.l.)
  DWSET(Length,  wdthLum)  //  WIDTH OF THE LUMPED MATERIAL
  DWSET(Length,  zOvlp)    //  min Z OVERLAP +\- 2 sigma from origin
  DWSET(Length,  guard)    //  width of Guard Ring at crystal border
  DWSET(Length,  res)      //  width of polySi resistors at z ends of modules
  DWSET(Length,  elecZ)    //  The Board length
  DWSET(Length,  sep)      //  radial sep between modules adjacent in z
  DWSET(Length,  inn1)     //  INNER RADIUS OF CABLE 1
  DWSET(Length,  out1)     //  OUTER RADIUS OF CABLE 1
  DWSET(Length,  inn2)     //  INNER RADIUS OF CABLE 2
  DWSET(Length,  out2)     //  OUTER RADIUS OF CABLE 2
  DWSET(Number,  thInsu)   //  Insulator thickness (in % of r.l.)
  
  //----------------------------------------------------
  //---------- Some extra/redefined quantities ---------
  //----------------------------------------------------

  DWSET(Angle,   stereoInner)     // (as viewed from I.P.)
  DWSET(Angle,   stereoOuter)     // (as viewed from I.P.)
  DWSET(Length,  waferThickness)
  DWSET(Length,  waferWidth)   
  DWSET(Length,  waferLength)
  DWSET(Length,  sectGap)       
  DWSET(Length,  waferSep)     
  DWSET(Length,  radEle)   
  DWSET(Length,  radIso)  
  DWSET(Length,  radSup) 
  DWSET(Length,  radLum) 
  DWSET(Integer, nModulesPerSki)

  DWSETARRAY(Length, zModuleOffset, nModulesPerSki)
  
  //----------------------------------------------------
  //---------- Some layer dependant quantities ---------
  //----------------------------------------------------

  DWSETARRAY(Length,  layerRadius,  nLay)  
  DWSETARRAY(Number,  rTckSup,      nLay)  
  DWSETARRAY(Angle,   tiltOfLayer,  nLay)  
  DWSETARRAY(Integer, skisPerLayer, nLay)  
  DWSETARRAY(Length,  r0Sup,        nLay)  
  DWSETARRAY(Length,  flLen,        nLay)  
  DWSETARRAY(Number,  flTck,        nLay)  
  DWSETARRAY(Length,  cOLen,        nLay)  
  DWSETARRAY(Number,  cOTck,        nLay)  
  
  //----------------------------------------------------------
  //---------- Now let's derive some quantities.  ------------
  //---------- We don't HAVE to do this here;     ------------
  //---------- some params are better defined     ------------
  //---------- further on inside loops.           ------------
  //----------------------------------------------------------

  const double boardWidth      = dYSect-waferWidth;
  const double tckEle          = (rTckEle/DWfraction) * radEle;
  const double tckLum          = (rTckLum/DWfraction) * radLum;
  const double tckIso          = (thInsu /DWfraction) * radIso;
  const double sectThickness   = max((double) waferThickness, tckEle);
  const double sectWidth       = waferWidth+2.0*boardWidth;
  const double sectLength      = max(waferLength*2.0+waferSep, (double) elecZ);
  const double maxStereo       = max(abs(stereoInner), abs(stereoOuter));
  const double moduleThickness = 2.0*sectThickness+sectGap;
  const double moduleWidth     = sectWidth*cos(maxStereo/DWradian)+
                                 sectLength*sin(maxStereo/DWradian);
  const double moduleLength    = sectWidth*sin(maxStereo/DWradian)+
                                 sectLength*cos(maxStereo/DWradian);
  const double zCylEnd         = hLen - tckIso;
  const double dXSectB         = waferThickness/2.+sectGap/2.;
  const double dYSectB         = dYSect-waferWidth/2.+sectGap/2.;
  const double dZSectB         = sectLength/2.+sectGap/2.;
  const double stRA            = max(abs(stereoInner),abs(stereoOuter));
  const double dXTMou          = 2.*dXSectB+0.1*sep;
  const double dYTMou          = dYSectB*cos(stRA/DWradian)+
                                 dZSectB*sin(stRA/DWradian)+
                                 0.1*sep;
  const double dZTMou          = dYSectB*sin(stRA/DWradian)+
                                 dZSectB*cos(stRA/DWradian)+
                                 0.1*sep;

  vector<double> tckSup(nLay);
  vector<double> tckFl (nLay);
  vector<double> tckClo(nLay);
  for (int i=0; i<nLay; i++) {
    tckSup[i] = (rTckSup[i]/DWfraction)*radSup;
    tckFl [i] = (flTck  [i]/DWfraction)*radSup;
    tckClo[i] = (cOTck  [i]/DWfraction)*radSup;
  }

  // ----------------------------------------------------------
  // --------- Now here actually comes the geometry -----------
  // ----------------------------------------------------------

// Here is a Wafer.
#ifdef BAF
{ 
  df << DWBegin("Wafer");
  df << DWBox(waferThickness, waferWidth, waferLength);
  df << DWEnd("Wafer");
}
#else
agdb::Solid & wafer = barrelSection.adopt(new agdb::Solid());
wafer.setName("sct_wafer");
wafer.setBox(waferThickness, waferWidth, waferLength);
wafer.setMaterial("cheese");
barrelSection.addVolume(wafer);
#endif

// Here is a DoubleWafer.
#ifdef BAF
{ 
  df << DWBegin("DoubleWafer");
  df << DWBox(waferThickness, waferWidth, waferLength*2.0+waferSep);
  df << DWPlacement("Wafer", 0, 0, +(waferLength+waferSep)/2.0);
  df << DWPlacement("Wafer", 0, 0, -(waferLength+waferSep)/2.0);
  df << DWEnd("DoubleWafer");
}
#else
agdb::PosXYZ & topWafer = barrelSection.adopt(new agdb::PosXYZ());
agdb::PosXYZ & botWafer = barrelSection.adopt(new agdb::PosXYZ());
topWafer.setVolume(wafer);
botWafer.setVolume(wafer);
topWafer.setXYZ(0., 0., +(waferLength+waferSep)/2.0);
botWafer.setXYZ(0., 0., -(waferLength+waferSep)/2.0);
agdb::Compos & doubleWafer = barrelSection.adopt(new agdb::Compos());
doubleWafer.setName("sct_doubleWafer");
doubleWafer.addPos(topWafer);
doubleWafer.addPos(botWafer);
barrelSection.addVolume(doubleWafer);
#endif

// Here is an ElectronicsBoard
#ifdef BAF
  { 
    df << DWBegin("ElectronicsBoard");
    df << DWBox(tckEle, boardWidth, elecZ);
    df << DWEnd("ElectronicsBoard");
  }
#else
agdb::Solid & electronicsBoard = barrelSection.adopt(new agdb::Solid());
electronicsBoard.setName("sct_electronicsBoard");
electronicsBoard.setBox(tckEle, boardWidth, elecZ);
electronicsBoard.setMaterial("cheese");
barrelSection.addVolume(electronicsBoard);
#endif

// Here is a SECT
#ifdef BAF
  { 
    df << DWBegin("SECT");
    df << DWBox(sectThickness, sectWidth, sectLength);
    df << DWPlacement("DoubleWafer");
    df << DWPlacement("ElectronicsBoard",0,-(waferWidth+boardWidth)/2.0,0);
    df << DWEnd("SECT");
  }
#else
agdb::PosXYZ & waferPos = barrelSection.adopt(new agdb::PosXYZ());
agdb::PosXYZ & boardPos = barrelSection.adopt(new agdb::PosXYZ());
waferPos.setVolume(doubleWafer);
boardPos.setVolume(electronicsBoard);
boardPos.setXYZ(0., -(waferWidth+boardWidth)/2.0, 0.);
agdb::Compos & sect = barrelSection.adopt(new agdb::Compos());
sect.setName("sct_sect");
sect.addPos(waferPos);
sect.addPos(boardPos);
barrelSection.addVolume(sect);
#endif

// Here is an SLMP.
#ifdef BAF
{ //
  // NOTE:
  // This implementation fixes a bug in the old G3 
  // definition which read something like:
  // df << DWBox(tckLum, wdthLum, hLen*2.);
  // which caused the lump volume to overlap the 
  // insulation volume.
  // I substitute this instead.
  df << DWBegin("SLMP");
  df << DWBox(tckLum, wdthLum, zCylEnd*2.);
  df << DWEnd("SLMP");
}
#else
// NOTE:
// This implementation fixes a bug in the old G3 
// definition which read something like:
// df << DWBox(tckLum, wdthLum, hLen*2.);
// which caused the lump volume to overlap the 
// insulation volume.
// I substitute this instead.
agdb::Solid & slmp = barrelSection.adopt(new agdb::Solid());
slmp.setName("sct_slmp");
slmp.setBox(tckLum, wdthLum, zCylEnd*2.);
slmp.setMaterial("cheese");
barrelSection.addVolume(slmp);
#endif

// Here is a SCAB which is a representation of cabling.
#ifdef BAF
{ 
  df << DWBegin("SCAB");
  df << DWCons(inn1, out1, inn2, out2, zCylEnd); 
  df << DWEnd("SCAB");    
} 
#else
agdb::Solid & scab = barrelSection.adopt(new agdb::Solid());
scab.setName("sct_scab");
scab.setCons(inn1,out1, inn2,out2, zCylEnd);
scab.setMaterial("cheese");
barrelSection.addVolume(scab);
#endif

// Here is a DoubleSCAB
#ifdef BAF
{ 
  df << DWBegin("DoubleSCAB");
  df << DWTubs(min(inn1,inn2), max(out1,out2), zCylEnd*2.);
  df << DWPlacement("SCAB", 0, 0, +zCylEnd/2., 0,   0.*DWdegree, 0);
  df << DWPlacement("SCAB", 0, 0, -zCylEnd/2., 0, 180.*DWdegree, 0);
  df << DWEnd("DoubleSCAB");
}
#else
agdb::PosXYZ & posPos = barrelSection.adopt(new agdb::PosXYZ());
agdb::PosXYZ & negPos = barrelSection.adopt(new agdb::PosXYZ());
posPos.setVolume(scab);
negPos.setVolume(scab);
posPos.setXYZ(0., 0., +zCylEnd/2.);
negPos.setXYZ(0., 0., -zCylEnd/2.);
posPos.setRot(0.,   0.*DWdegree, 0.);
negPos.setRot(0., 180.*DWdegree, 0.);
agdb::Compos & doubleScab = barrelSection.adopt(new agdb::Compos());
doubleScab.setName("sct_doubleScab");
doubleScab.addPos(posPos);
doubleScab.addPos(negPos);
barrelSection.addVolume(doubleScab);
#endif

// Here are nLay Flanges
#ifdef BAF
{ 
  for (int i=0; i<nLay; i++) {
    ostrstream o; o << "Flange" << i+1 << ends;
    string name=o.str();
    df << DWBegin(name);
    df << DWTubs(r0Sup[i]-flLen[i], r0Sup[i], tckFl[i]);
    df << DWEnd(name);
  }
}
#else
vector<agdb::Solid *> flange;
{
  for (int i=0; i<nLay; i++) {
    flange.push_back(&barrelSection.adopt(new agdb::Solid()));
    ostrstream o; o << "sct_flange" << i+1 << ends;
    flange[i]->setName(o.str());
    flange[i]->setTubs(r0Sup[i]-flLen[i], r0Sup[i], tckFl[i]);
    flange[i]->setMaterial("cheese");
    barrelSection.addVolume(flange[i]);
  }
}
#endif

// Here are nLay CloseOuts
#ifdef BAF
{
  for (int i=0; i<nLay; i++) {
    ostrstream o; o << "CloseOut" << i+1 << ends;
    string name=o.str();
    df << DWBegin(name);
    df << DWTubs(r0Sup[i]-tckClo[i], r0Sup[i], cOLen[i]);
    df << DWEnd(name);
  }
}
#else
vector<agdb::Solid *> closeOut;
{
  for (int i=0; i<nLay; i++) {
    closeOut.push_back(&barrelSection.adopt(new agdb::Solid()));
    ostrstream o; o << "sct_closeOut" << i+1 << ends;
    closeOut[i]->setName(o.str());
    closeOut[i]->setTubs(r0Sup[i]-tckClo[i], r0Sup[i], cOLen[i]);
    closeOut[i]->setMaterial("cheese");
    barrelSection.addVolume(closeOut[i]);
  }
}
#endif

// Here are nLay Supports
#ifdef BAF
{
  for (int i=0; i<nLay; i++) {
    ostrstream o; o << "Support" << i+1 << ends;
    string name=o.str();
    df << DWBegin(name);
    df << DWTubs(r0Sup[i]-tckSup[i],r0Sup[i],2.*(zCylEnd-cOLen[i]-tckFl[i]));
    df << DWEnd(name);
  }
}
#else
vector<agdb::Solid *> support;
{
  for (int i=0; i<nLay; i++) {
    support.push_back(&barrelSection.adopt(new agdb::Solid()));
    ostrstream o; o << "sct_support" << i+1 << ends;
    support[i]->setName(o.str());
    support[i]->setTubs(r0Sup[i]-tckSup[i],r0Sup[i],2.*(zCylEnd-cOLen[i]-tckFl[i]));
    support[i]->setMaterial("cheese");
    barrelSection.addVolume(support[i]);
  }
}
#endif

// Here is the InsulationEnd
#ifdef BAF
{ 
  df << DWBegin("InsulationEnd");
  df << DWTubs(rMin, rMax, tckIso);
  df << DWEnd("InsulationEnd");
}
#else
agdb::Solid & insulationEnd = barrelSection.adopt(new agdb::Solid());
insulationEnd.setName("sct_insulationEnd");
insulationEnd.setTubs(rMin, rMax, tckIso);
insulationEnd.setMaterial("cheese");
barrelSection.addVolume(insulationEnd);
#endif

// Here is the InsulationCyl
#ifdef BAF
{ 
  df << DWBegin("InsulationCyl");
  df << DWTubs(rMax-tckIso, rMax, 2.*zCylEnd);
  df << DWEnd("InsulationCyl");
}
#else
agdb::Solid & insulationCyl = barrelSection.adopt(new agdb::Solid());
insulationCyl.setName("sct_insulationCyl");
insulationCyl.setTubs(rMax-tckIso, rMax, 2.*zCylEnd);
insulationCyl.setMaterial("cheese");
barrelSection.addVolume(insulationCyl);
#endif

// Here is are two BarrelModules, Type1 and Type2 (Positive/negative stereo)
#ifdef BAF
{ 
  for (int i=0; i<2; i++) {
    string name;
    if (i==0) {
      name=string("BarrelModuleType1");
    } else {
      name=string("BarrelModuleType2");
    }
    
    df << DWBegin(name);
    df << DWBox(moduleThickness, 
		moduleWidth, 
		moduleLength);
    
    // First the inner SECT
    if (i==0) {
      df << DWPlacement("SECT", -(sectThickness+sectGap)/2., 0, 0, +stereoInner/DWdegree, 0, 0);
    } else {
      df << DWPlacement("SECT", -(sectThickness+sectGap)/2., 0, 0, -stereoInner/DWdegree, 0, 0);
    }
    
    // now the outer SECT
    df << DWPlacement("SECT", +(sectThickness+sectGap)/2., 0, 0);
    
    df << DWEnd(name);
  }
} 
#else
agdb::PosXYZ & posInnerSectPos = barrelSection.adopt(new agdb::PosXYZ());
agdb::PosXYZ & negInnerSectPos = barrelSection.adopt(new agdb::PosXYZ());
agdb::PosXYZ &    OuterSectPos1 = barrelSection.adopt(new agdb::PosXYZ());
agdb::PosXYZ &    OuterSectPos2 = barrelSection.adopt(new agdb::PosXYZ());
posInnerSectPos.setVolume(sect);
negInnerSectPos.setVolume(sect);
   OuterSectPos1.setVolume(sect);
   OuterSectPos2.setVolume(sect);
posInnerSectPos.setXYZ(-(sectThickness+sectGap)/2., 0., 0.);
negInnerSectPos.setXYZ(-(sectThickness+sectGap)/2., 0., 0.);
   OuterSectPos1.setXYZ(+(sectThickness+sectGap)/2., 0., 0.);
   OuterSectPos2.setXYZ(+(sectThickness+sectGap)/2., 0., 0.);
posInnerSectPos.setRot(+stereoInner/DWdegree, 0., 0.); // LESTER Check sign
negInnerSectPos.setRot(-stereoInner/DWdegree, 0., 0.); // LESTER Check sign

agdb::Compos & posModule = barrelSection.adopt(new agdb::Compos());
agdb::Compos & negModule = barrelSection.adopt(new agdb::Compos());
posModule.setName("sct_posBarrelModule");
negModule.setName("sct_negBarrelModule");
posModule.addPos(posInnerSectPos);
negModule.addPos(negInnerSectPos);
posModule.addPos(   OuterSectPos1);
negModule.addPos(   OuterSectPos2);
barrelSection.addVolume(posModule);
barrelSection.addVolume(negModule);
#endif
// That's the end of the barrel modules.


// Here are the nLay types of ski.
#ifdef BAF
{ 
  int i;
  int sn; // This shall take values indicative of the
  // module type to use on each layer.
  for ((i=0, sn=2); i<nLay; (i++, sn=((sn==1)?2:1))) {
    ostrstream os; os << "SkiType" << i+1 << ends;
    string skiName = os.str();
    
    ostrstream om; om << "BarrelModuleType" << sn << ends;
    string moduleName = om.str();
    
    df << DWBegin(skiName);
    df << DWBox(moduleThickness+sep, 
		moduleWidth, 
		moduleLength+abs(zModuleOffset[nModulesPerSki-1]-zModuleOffset[0]));
    {
      int sn; // Will oscillate with the radial staggering.
      int j;
      for ((sn=-1, j=0); j<nModulesPerSki; (j++, sn=-sn)) {
	df << DWPlacement(moduleName, sn*sep/2.0, 0, zModuleOffset[j] );
      }
    }
    df << DWEnd(skiName);
  } // Here ends the ith type of ski
} 
#else
vector<agdb::Compos *> ski;
{
  for (int i=0; i<nLay; i++) {
    ostrstream o; o << "sct_skiType" << i+1 << ends;
    ski.push_back(&barrelSection.adopt(new agdb::Compos()));
    ski[i]->setName(o.str());

    int sn; // Will oscillate with the radial staggering.
    int j;  // Module number
    for ((sn=-1, j=0); j<nModulesPerSki; (j++, sn=-sn)) {
      agdb::PosXYZ & modulePos = barrelSection.adopt(new agdb::PosXYZ);
      modulePos.setVolume( (i==0 || i==2) ? negModule : posModule );
      modulePos.setXYZ(sn*sep/2.0, 0., zModuleOffset[j]);
      ski[i]->addPos(modulePos);
    }
    barrelSection.addVolume(ski[i]);
  }
}
#endif
// There end all the skis.

{ // Here comes the Barrel. (This is a long one.)
  int i;     // Loop variable to represent the layer.
  int sn;    // Dummy variable indicating skiType.
  
#ifdef BAF
  df << DWBegin("Barrel");
  df << DWTubs(rMin, rMax, hLen*2);
#endif
  
  // First will position entities which
  // there are "one of" per layer.
  
  // Here starts the loop over the layers in the barrel.
  for ((sn=1,i=0); i<nLay; (i++,sn=1-sn)) {
    // First a couple of temporary variables.      
    double temp1;
    double temp2;
    
    // Now for some layer dependent quantities
    // which will be useful for the positionings
    // which follow.
    const double angle  = 360. * DWdegree / skisPerLayer[i];
    const double tilt   = tiltOfLayer[i];
    const double dXSki  = sep/2.+dXTMou;	
    temp1               = layerRadius[i]+dXSki*cos(tilt/DWradian)-dYTMou*sin(tilt/DWradian);
    temp2               =                dXSki*sin(tilt/DWradian)+dYTMou*cos(tilt/DWradian);
    const double rad2   = sqrt(temp1*temp1+temp2*temp2);
    const double rad1a  = layerRadius[i]-(rad2-layerRadius[i]);
    temp1               = rad1a;
    temp2               = wdthLum/2.;
    temp1               = temp1*temp1-temp2*temp2;
    
    // Am about to take a square root so ...
    assert(temp1>=0);
    
    const double rad1   = sqrt(temp1)-max(tckLum, 2.*out2); 
    const double rCab   = rad1 + out2;
    const double yCab   = max(wdthLum/2., rCab*tan((angle/4.)/DWradian));	
    const double wactrot = sectLength*sin(stRA/DWradian)+waferWidth*cos(stRA/DWradian);
    const double delX    = layerRadius[i]+(-dXSki*cos(tilt/DWradian)+(wactrot/2.)*sin(tilt/DWradian));
    const double delY    =                (+dXSki*sin(tilt/DWradian)+(wactrot/2.)*cos(tilt/DWradian));
    const double alpha   = angle/2.-atan(delY/delX)*DWradian;
    const double rLump = rad1 + tckLum/2.;
    
    // OK.  That's all the variables we need to define.
    // Let's get going with the placements.

#ifndef BAF
    // First we make a composition for the layer:
    agdb::Compos & layer = barrelSection.adopt(new agdb::Compos);
    layer.setName("sct_layer"+barrelSection.makeNumberString(i+1.));
    barrelSection.addVolume(layer);
    // and then we place it in the barrel:
    agdb::PosXYZ & layerPos = barrelSection.adopt(new agdb::PosXYZ);
    layerPos.setVolume(layer);
    barrelCompos.addPos(layerPos);
#endif

// Position the Lump and Cables 
#ifdef BAF
    { 
      df << DWPhisymm("SLMP",
		      skisPerLayer[i],
		      rLump);
      df << DWPhisymm("DoubleSCAB",
		      skisPerLayer[i],
		      sqrt(rCab*rCab+yCab*yCab),
		      0,
		      0,0,0,
		      atan(yCab/rCab)*DWradian
		      );
    } 
#else
    agdb::MPosPhi & slmpPos = barrelSection.adopt(new agdb::MPosPhi);
    slmpPos.setVolume(slmp);
    slmpPos.setN(skisPerLayer[i]);
    slmpPos.setRZ(rLump, 0.);
    layer.addPos(slmpPos);

    agdb::MPosPhi & doubleScabPos = barrelSection.adopt(new agdb::MPosPhi);
    doubleScabPos.setVolume(doubleScab);
    doubleScabPos.setN(skisPerLayer[i]);
    doubleScabPos.setRZ(sqrt(rCab*rCab+yCab*yCab), 0.);
    doubleScabPos.setPhi0(atan(yCab/rCab)*DWradian); //LESTER Check sign
    layer.addPos(doubleScabPos);
#endif
    // That's finished positioning the cables.

    // Here come the skis.
#ifdef BAF
    { 
      ostrstream o; o << "SkiType"<< i+1 << ends;
      string skiName = o.str();
      
      df << DWPhisymm(skiName,
		      skisPerLayer[i],
		      layerRadius[i],
		      0,
		      0, 0, -tiltOfLayer[i],
		      alpha+angle ); 
    }
#else
    agdb::MPosPhi & skiPos = barrelSection.adopt(new agdb::MPosPhi);
    skiPos.setVolume(ski[i]);
    skiPos.setN(skisPerLayer[i]);
    skiPos.setRZ(layerRadius[i], 0.);
    skiPos.setRot(0., 0., -tiltOfLayer[i]); //LESTER Check sign
    skiPos.setPhi0(alpha+angle);
    layer.addPos(skiPos);
#endif
    // That completes the skis.

    // Position the CloseOuts, flanges and Supports
#ifdef BAF
    {
      string closeOutName;
      string supportName;
      string flangeName;
      {
	ostrstream o; o << "CloseOut" << i+1 << ends;
	closeOutName=o.str();
      }
      {
	ostrstream o; o << "Support" << i+1 << ends;
	supportName=o.str();
      }
      {
	ostrstream o; o << "Flange" << i+1 << ends;
	flangeName=o.str();
      }
      df << DWPlacement(flangeName,  0,0,+(zCylEnd-tckFl[i]/2.));
      df << DWPlacement(flangeName,  0,0,-(zCylEnd-tckFl[i]/2.));
      df << DWPlacement(closeOutName,0,0,+(zCylEnd-tckFl[i]-cOLen[i]/2.));
      df << DWPlacement(closeOutName,0,0,-(zCylEnd-tckFl[i]-cOLen[i]/2.));
      df << DWPlacement(supportName);
    }
#else
    agdb::PosXYZ & posCloseOutPos = barrelSection.adopt(new agdb::PosXYZ);
    agdb::PosXYZ & negCloseOutPos = barrelSection.adopt(new agdb::PosXYZ);
    posCloseOutPos.setVolume(closeOut[i]);
    negCloseOutPos.setVolume(closeOut[i]);
    posCloseOutPos.setXYZ(0., 0., +(zCylEnd-tckFl[i]-cOLen[i]/2.));
    negCloseOutPos.setXYZ(0., 0., -(zCylEnd-tckFl[i]-cOLen[i]/2.));
    layer.addPos(posCloseOutPos);
    layer.addPos(negCloseOutPos);

    agdb::PosXYZ & posFlangePos = barrelSection.adopt(new agdb::PosXYZ);
    agdb::PosXYZ & negFlangePos = barrelSection.adopt(new agdb::PosXYZ);
    posFlangePos.setVolume(flange[i]);
    negFlangePos.setVolume(flange[i]);
    posFlangePos.setXYZ(0., 0., +(zCylEnd-tckFl[i]/2.));
    negFlangePos.setXYZ(0., 0., -(zCylEnd-tckFl[i]/2.));
    layer.addPos(posFlangePos);
    layer.addPos(negFlangePos);

    agdb::PosXYZ & supportPos = barrelSection.adopt(new agdb::PosXYZ);
    supportPos.setVolume(support[i]);
    layer.addPos(supportPos);
#endif
    // That's all the CloseOuts, flanges and Supports done.
    
  }  // End of loop over layers.
  
  // Now come the layer independent placements.
  
  // The insulating stuff
#ifdef BAF
  df << DWPlacement("InsulationCyl");
  df << DWPlacement("InsulationEnd",0,0,+(hLen-tckIso/2.));
  df << DWPlacement("InsulationEnd",0,0,-(hLen-tckIso/2.));
#else
  agdb::PosXYZ & insulationCylPos = barrelSection.adopt(new agdb::PosXYZ);
  insulationCylPos.setVolume(insulationCyl);
  barrelCompos.addPos(insulationCylPos);

  agdb::PosXYZ & posInsulationEndPos = barrelSection.adopt(new agdb::PosXYZ);
  agdb::PosXYZ & negInsulationEndPos = barrelSection.adopt(new agdb::PosXYZ);
  posInsulationEndPos.setVolume(insulationEnd);
  negInsulationEndPos.setVolume(insulationEnd);
  posInsulationEndPos.setXYZ(0., 0., +(hLen-tckIso/2.));
  negInsulationEndPos.setXYZ(0., 0., -(hLen-tckIso/2.));
  barrelCompos.addPos(posInsulationEndPos);
  barrelCompos.addPos(negInsulationEndPos);
#endif

#ifdef BAF
  df << DWEnd("Barrel");
#endif
} // That was the end of the Barrel and skis.

#ifdef BAF
df << "#close Barrel" << endl;

{ // Here is the SCT total
  df << DWBegin("SCT");
  df << DWTubs(25.*DWcm, 55.*DWcm, 3.*DWm); // Guessed
  df << DWPlacement("Barrel");  
  df << DWEnd("SCT");
} // Here ends the SCT total
df << "#close SCT" << endl;
#endif