LCD_DocGeoUtil.cc

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// $Id: LCD_DocGeoUtil.cc,v 1.9 2004/02/02 22:12:48 uid561 Exp $
// ----------------------------------------------------------------------------
//
// LCD_DocGeoUtil.cxx
//
// Utilities for sorting out elements peculiar to LCD detector
// geometry description
#include "LCD_DocGeoUtil.hh"
#include "LCD_DocumentUtil.hh"
#include "LCD_DocManager.hh"
#include "LCD_Document.hh"  // not strictly nec. since in included in above

XERCES_CPP_NAMESPACE_USE

// Forward declaration of local routine used in public xxxDim routines
static double getTotalThickness(DOM_Element shape);

// Given an element of tag type "layering" or with a child of this
// return total width of layers or width of a single layer

/*
 * Comment
 */
double LCD_DocGeoUtil::getLayerWidth(DOM_Element elt, bool all) {
  DOM_Element layering;
  if ((elt.getTagName()).equals("layering")) {
    layering = elt;
  }
  else {
    layering = LCD_DocumentUtil::firstDesc(elt, "layering");
    if (layering == 0) return -1.0;       // throw exception??
  }
  DOM_NodeList list = layering.getElementsByTagName(DOMString("slice"));
  int          nSlice = list.getLength();
  int          iSlice;
  DOM_Element  tmpElt;
  double       tmpValue;
  double       width = 0.0;
  bool         ok;

  // Compute width of a single layer by adding up width of slices
  for (iSlice = 0; iSlice < nSlice; iSlice++) {
    DOM_Node node = list.item(iSlice);
    tmpElt = (DOM_Element &) node;
    ok =
      LCD_DocumentUtil::convertValue(tmpElt.getAttribute(DOMString("width")),
                                     &tmpValue);
    width += tmpValue;
  }
  if (!all) return width;

  // multiply by number of layers
  int nLayer;

  ok = LCD_DocumentUtil::convertValue(layering.getAttribute("n"), &nLayer);
  width *= nLayer;

  return width;
}

/*
 * Comment
 */
bool LCD_DocGeoUtil::reflected(const DOM_Element& vol)
{
  bool refl;

  // Complex volumes cannot be reflected
  if (!(vol.getTagName().equals("volume"))) return false;

  // Get first child.  Should be tube, disk or cone, all of which
  // have a "reflected" attribute
  DOM_Element shape = LCD_DocumentUtil::firstDesc(vol, "*");

  //  if (vol.getAttributeNode("reflected") == 0) return false;
  DOMString reflValue = shape.getAttribute("reflected");

  if (reflValue.equals("")) return false;

  bool ok = LCD_DocumentUtil::convertValue(reflValue, &refl);
  if (ok) return refl;
  else return false;

  /*  if (LCD_DocumentUtil::convertValue(vol.getAttribute("reflected"), &refl)) {
      return refl;
      }
      else return false; */
}


// Given a barrel (centered tube), return  inner_r, outer_z and
// (optionally) outer_r

/*
 * Comment
 */
bool LCD_DocGeoUtil::barrelDim(const DOM_Element& tube, double *  pInnerR,
                               double * pOuterZ, double * pOuterR) {
  bool   ok;

  if (!(tube.getTagName().equals("tube"))) return false;

  DOM_Element dim;

  // In content model for tube, first child element is either
  // tube_dimensions, barrel_dimensions or neighbor.  This routine
  // can't handle tube_dimensions.  barrel_dimensions case is
  // straigthtforward except for outer r.  In neighbor case
  // we have to do extra work to get dimensions.
  DOM_Element elt = LCD_DocumentUtil::firstDesc(tube, "*");

  if ((elt.getTagName().equals("neighbor"))) {  // implies barrel
    DOMString neighborId = elt.getAttribute("adjoins");
    double    gap;
    double    neighInnerR, neighOuterR;

    ok = LCD_DocumentUtil::convertValue(elt.getAttribute("gap"), &gap);

    // get neighboring element.
    // First need to get our enclosing LCD_Document
    DOM_Document domDoc = elt.getOwnerDocument();

    // This may not be right -- could be complex volume
    elt = (LCD_DocManager::getLCDDoc(domDoc))->getElement(neighborId,
                                                          DOMString("volume"));

    // it better be a tube
    elt = LCD_DocumentUtil::firstDesc(elt, "tube");

    // Call ourselves to get its dimensions, in particular outer r
    // and outer z
    tubeDim(elt, &neighInnerR, pOuterZ, &neighOuterR);

    *pInnerR = neighOuterR + gap;
  }

  else if ((elt.getTagName().equals("barrel_dimensions"))) {
    dim = elt;
    ok =
      LCD_DocumentUtil::convertValue(dim.getAttribute(DOMString("inner_r")),
                                     pInnerR);

    if (ok)
      ok =
        LCD_DocumentUtil::convertValue(dim.getAttribute(DOMString("outer_z")),
                                       pOuterZ);
  }
  else return false;

  if (pOuterR) *pOuterR = *pInnerR + getTotalThickness(tube);
  return ok;
}

// Return parameters of a not-necessarily-centered tube.  offset
// returned is distance from center of tube to origin.

/*
 * Comment
 */
bool LCD_DocGeoUtil::tubeDim(const DOM_Element& tube, double *pInnerR,
                             double *pOffsetZ, double *pLength,
                             double *pOuterR) {

  bool ok;
  if (!(tube.getTagName().equals("tube"))) return false;

  DOM_Element dim = LCD_DocumentUtil::firstDesc(tube, "*");

  if (((dim.getTagName().equals("barrel_dimensions") )  ) ||
      ((dim.getTagName().equals("neighbor") )  )            ) {
    double outerZ;

    ok = barrelDim(tube, pInnerR, &outerZ, pOuterR);

    if (ok) {
      *pOffsetZ = 0.0;
      *pLength = 2 * outerZ;
    }
    return ok;
  }
  else if (dim.getTagName().equals("tube_dimensions")) {
    ok =
      LCD_DocumentUtil::convertValue(dim.getAttribute(DOMString("inner_r")),
                                     pInnerR);
    if (ok)
      ok =
        LCD_DocumentUtil::convertValue(dim.getAttribute(DOMString("offset_z")),
                                       pOffsetZ);
    if (ok)
      ok =
        LCD_DocumentUtil::convertValue(dim.getAttribute(DOMString("length")),
                                       pLength);
    if (!pOuterR) return ok;
    if (!ok) return false;
    else *pOuterR = *pInnerR + getTotalThickness(tube);

    return true;
  }
  return false;  // improper first child
}


// Given a disk, return inner r, inner z, outer r and (optionally)
// outer z.

/*
 * Comment
 */
bool LCD_DocGeoUtil::diskDim(const DOM_Element& disk, double *pInnerR,
                             double *pInnerZ, double *pOuterR,
                             double *pOuterZ) {
  bool   ok;

  if (!(disk.getTagName().equals("disk"))) return false;

  DOM_Element dim;

  // In content model for disk, first child element is either disk_dimensions
  // or neighbor.  In latter case we have to do extra work to get
  // dimensions.
  DOM_Element elt = LCD_DocumentUtil::firstDesc(disk, "*");

  if ((elt.getTagName().equals("neighbor"))) {
    DOMString neighborId = elt.getAttribute("adjoins");
    double    gap;
    double    neighOuterZ;

    ok = LCD_DocumentUtil::convertValue(elt.getAttribute("gap"), &gap);

    // get neighboring element. Our inner R, outer R will be the
    // same as the neighbor's. To get our inner Z, take neighbor's
    // outer Z and add gap
    // First need to get our enclosing LCD_Document
    DOM_Document domDoc = elt.getOwnerDocument();

    // Not quite right since it also could be a complex volume
    elt = (LCD_DocManager::getLCDDoc(domDoc))->getElement(neighborId,
                                                          DOMString("volume"));

    // could be tube or another disk.  If a tube, had better be barrel type
    elt = LCD_DocumentUtil::firstDesc(elt, "*");

    if ((elt.getTagName()).equals("tube")) {
      barrelDim(elt, pInnerR, &neighOuterZ, pOuterR);
    }
    else if ((elt.getTagName()).equals("disk")) {
      double tmp;     // for neighbor inner Z, which we don't need
      diskDim(elt, pInnerR, &tmp, pOuterR, &neighOuterZ);
    }

    *pInnerZ = neighOuterZ + gap;
  }

  else { // it's a disk_dimension element
    ok =
      LCD_DocumentUtil::convertValue(elt.getAttribute(DOMString("inner_r")),
                                     pInnerR);

    if (ok)
      ok =
        LCD_DocumentUtil::convertValue(elt.getAttribute(DOMString("inner_z")),
                                       pInnerZ);

    if (ok)
      ok =
        LCD_DocumentUtil::convertValue(elt.getAttribute(DOMString("outer_r")),
                                       pOuterR);
  }

  if (pOuterZ)  *pOuterZ = *pInnerZ + getTotalThickness(disk);

  return ok;
}

// This is just a private utility.  We can assume shape is
// a DOM_Element of the proper type
static double getTotalThickness(DOM_Element shape) {
  double      tmpValue;
  DOM_NodeList list = shape.getElementsByTagName(DOMString("slice"));
  DOM_Element  tmpElt;
  double       width;
  bool         ok;

  // Get width due to layers
  tmpElt = LCD_DocumentUtil::firstDesc(shape, "layering");
  width = LCD_DocGeoUtil::getLayerWidth(tmpElt, true);

  // add on width of inner wall, if any
  tmpElt = LCD_DocumentUtil::firstDesc(shape, DOMString("iwall"));
  if (tmpElt != DOM_Element()) {
    ok = LCD_DocumentUtil::convertValue(tmpElt.getAttribute("width"),
                                        &tmpValue);
    width += tmpValue;
  }

  // add on width of outer wall, if any
  tmpElt = LCD_DocumentUtil::firstDesc(shape, "owall");
  if (tmpElt != DOM_Element()) {
    ok = LCD_DocumentUtil::convertValue(tmpElt.getAttribute("width"),
                                        &tmpValue);
    width += tmpValue;
  }
  return width;
}

/*
 * Comment
 */
bool LCD_DocGeoUtil::coneDim(const DOM_Element& cone,
                             double *pMinInnerR, double *pMinOuterR,
                             double *pMaxInnerR, double *pMaxOuterR,
                             double *pInnerZ, double *pOuterZ) {

  double innerWidth, outerWidth;

  if (!(cone.getTagName().equals("cone"))) return false;

  DOM_Element child = LCD_DocumentUtil::firstDesc(cone, "cone_dimensions");

  if (!LCD_DocumentUtil::convertValue(child.getAttribute("min_inner_r"),
                                      pMinInnerR)) return false;
  if (!LCD_DocumentUtil::convertValue(child.getAttribute("max_inner_r"),
                                      pMaxInnerR)) return false;
  if (!LCD_DocumentUtil::convertValue(child.getAttribute("inner_z"),
                                      pInnerZ)) return false;
  if (!LCD_DocumentUtil::convertValue(child.getAttribute("outer_z"),
                                      pOuterZ)) return false;

  child = LCD_DocumentUtil::firstDesc(cone, "cone_slice");
  if (!LCD_DocumentUtil::convertValue(child.getAttribute("inner_width"),
                                      &innerWidth)) return false;
  if (child.getAttributeNode("outer_width") == 0) {
    outerWidth = innerWidth;
  }
  else {
    if (!LCD_DocumentUtil::convertValue(child.getAttribute("outer_width"),
                                        &outerWidth)) return false;
  }

  *pMinOuterR = *pMinInnerR + innerWidth;
  *pMaxOuterR = *pMaxInnerR + outerWidth;
  return true;
}

// The element "layered" should be a tube or disk (or just have one
// as descendant?)

/*
 * Comment
 */
double LCD_DocGeoUtil::getLayer0Dist(const DOM_Element& layered) {
  bool    ok;
  double  innerBound;

  if  ((layered.getTagName()).equals("tube")) {
    double offsetZ, length;  // will throw these away
    ok = tubeDim(layered, &innerBound, &offsetZ, &length);
  }
  else if  ((layered.getTagName()).equals("disk")) {
    double innerR, outerR; // will throw these away
    ok = diskDim(layered, &innerR, &innerBound, &outerR);
  }
  else return 0.0;  // throw exception??
  if (!ok) return 0.0; // throw exception??

  DOM_Element child = LCD_DocumentUtil::firstDesc(layered, "iwall");
  if (child == 0) return innerBound;

  double width;

  ok =
    LCD_DocumentUtil::convertValue(child.getAttribute(DOMString("width")),
                                   &width);
  if (ok) innerBound += width;
  return innerBound;
}


/*
 * Comment
 */
bool LCD_DocGeoUtil::getSegmentation(const DOM_Element& elt, double *nTheta,
                                     double *nPhi)
{
  bool ok;

  DOM_Element seg;
  if ((elt.getTagName()).equals("segmentation")) {
    seg = elt;
  }
  else {
    seg = LCD_DocumentUtil::firstDesc(elt, "segmentation");
    if (seg == 0) return false;       // throw exception??
  }

  // New files will say theta. Old files may say cos_theta
  ok =
    LCD_DocumentUtil::convertValue(seg.getAttribute(DOMString("theta")),
                                   nTheta);
  if (!ok) ok =
             LCD_DocumentUtil::convertValue(seg.getAttribute(DOMString("cos_theta")),
                                            nTheta);

  ok = ok &&
    LCD_DocumentUtil::convertValue(seg.getAttribute(DOMString("phi")),
                                   nPhi);
  return ok;
}

---