VolumeBuilder.cpp

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation 
//--------------------------------------------------------------------------
// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
// All rights reserved.
//
// For the licensing terms see $DD4hepINSTALL/LICENSE.
// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
//
// Author     : M.Frank
//
//==========================================================================
#ifndef DD4HEP_NONE
 
// Framework include files
#include <XML/VolumeBuilder.h>
#include <XML/Utilities.h>
#include <DD4hep/Printout.h>
#include <DD4hep/Plugins.h>
#include <DD4hep/Detector.h>
#include <DD4hep/DetFactoryHelper.h>
#include <Math/Polar2D.h>
 
#include <TClass.h>
 
using dd4hep::xml::tools::VolumeBuilder;
 
VolumeBuilder::VolumeBuilder(Detector& dsc, xml_h x_parent, SensitiveDetector sd)
  : description(dsc), x_det(x_parent), sensitive(sd)
{
  if ( x_det )   {
    name     = x_det.nameStr();
    id       = x_det.id();
    detector = DetElement(name, id);
  }
  buildType = description.buildType();
}
 
std::size_t VolumeBuilder::collectMaterials(xml_h element)   {
  std::size_t len = materials.size();
  for( xml_coll_t c(element,_U(material)); c; ++c )   {
    xml_comp_t  x_c = c;
    std::string nam = x_c.nameStr();
    std::string val = x_c.valueStr();
    Material    mat = description.material(val);
    materials[nam] = mat;
  }
  return materials.size()-len;
}
 
void VolumeBuilder::registerShape(const std::string& nam, Solid shape)   {
  auto is = shapes.find(nam);
  if( is == shapes.end() )  {
    shapes[nam] = std::make_pair(xml_h(0), shape);
    return;
  }
  except("VolumeBuilder","+++ Shape %s is already known to this builder unit. ",nam.c_str());
}
 
void VolumeBuilder::registerVolume(const std::string& nam, Volume volume)   {
  auto is = volumes.find(nam);
  if( is == volumes.end() )  {
    printout(debug ? ALWAYS : DEBUG,"VolumeBuilder",
             "+++ Register volume:            %-20s shape:%-24s vis:%s sensitive:%s",
             nam.c_str(),
             volume.solid()->IsA()->GetName(),
             volume.visAttributes().name(),
             yes_no(volume.isSensitive()));
    volumes[nam] = std::make_pair(xml_h(0), volume);
    return;
  }
  except("VolumeBuilder","+++ Volume %s is already known to this builder unit. ",nam.c_str());
}
 
dd4hep::Volume VolumeBuilder::volume(const std::string& nam)  const    {
  auto iv = volumes.find(nam);
  if( iv == volumes.end() )  {
    auto ib = vol_veto.find(nam);
    if( ib != vol_veto.end() )  {
      // Veto'ed shape. Ignore it.
      return Volume();
    }
    except("VolumeBuilder","+++ Volume %s is not known to this builder unit. ",nam.c_str());
  }
  Volume vol = (*iv).second.second;
  if( !vol.isValid() )   {
    except("VolumeBuilder","+++ Failed to access volume %s from the local cache.",nam.c_str());
  }
  return vol;
}
 
dd4hep::Transform3D VolumeBuilder::getTransform(const std::string& nam)  const   {
  auto it = transformations.find(nam);
  if( it == transformations.end() )  {
    except("VolumeBuilder","+++ Tranformation %s is not known to this builder unit. ",nam.c_str());
  }
  return (*it).second.second;
}
 
dd4hep::Solid VolumeBuilder::getShape(const std::string& nam)  const   {
  auto is = shapes.find(nam);
  if( is == shapes.end() )  {
    auto ib = shape_veto.find(nam);
    if( ib != shape_veto.end() )  {
      // Veto'ed shape. Ignore it.
      return Solid();
    }
    except("VolumeBuilder","+++ Shape %s is not known to this builder unit. ",nam.c_str());
  }
  Solid solid = (*is).second.second;
  if( !solid.isValid() )   {
    except("VolumeBuilder","+++ Failed to access shape %s from the local cache.",nam.c_str());
  }
  return solid;
}
 
dd4hep::Solid VolumeBuilder::makeShape(xml_h handle)   {
  xml_comp_t  x = handle;
  xml_attr_t  a = handle.attr_nothrow(_U(name));
  std::string nam;
  if( a )   {
    nam = handle.attr<std::string>(a);
    auto is = shapes.find(nam);
    if( is != shapes.end() )  {
      except("VolumeBuilder","+++ The named shape %s is already known to this builder unit. "
             "Cannot be overridden.",nam.c_str());
    }
  }
  if( !nam.empty() )   {
    auto iv = shape_veto.find(nam);
    if( iv != shape_veto.end() )  {
      return Solid();
    }
  }
  a = handle.attr_nothrow(_U(build));
  if( a )   {
    std::string build = handle.attr<std::string>(a);
    if( !buildMatch(build, buildType) )  {
      printout(INFO,"VolumeBuilder",
               "+++ Shape %s does NOT match build requirements. [Ignored]",nam.c_str());
      if( !nam.empty() ) shape_veto.emplace(nam);
      return Solid();
    }
  }
  std::string type = x.attr<std::string>(_U(type));
  Solid solid = xml::createShape(description, type, x);
  if( !solid.isValid() )   {
    except("VolumeBuilder","+++ Failed to create shape %s of type: %s",
           nam.c_str(), type.c_str());
  }
  if( !nam.empty() )   {
    solid.setName(nam);
    shapes.emplace(nam,std::make_pair(handle,solid));
  }
  printout(debug ? ALWAYS : DEBUG, "VolumeBuilder",
           "+++ Created shape of type: %s name: %s",type.c_str(), nam.c_str());
  return solid;
}
 
std::size_t VolumeBuilder::buildShapes(xml_h handle)    {
  std::size_t len = shapes.size();
  for( xml_coll_t c(handle,_U(shape)); c; ++c )   {
    xml_elt_t x = c;
    std::string nam = x.attr<std::string>(_U(name));
    auto is = shapes.find(nam);
    if( is == shapes.end() )  {
      xml_attr_t x_build = c.attr_nothrow(_U(build));
      if( x_build )   {
        std::string build = c.attr<std::string>(x_build);
        if( !buildMatch(build, buildType) )  {
          printout(INFO,"VolumeBuilder",
                   "+++ Shape %s does NOT match build requirements. [Ignored]",nam.c_str());
          shape_veto.emplace(nam);
          continue;
        }
      }
      std::string type  = x.attr<std::string>(_U(type));
      if( type == "Assembly" )  {
        continue;
      }
      Solid solid = xml::createShape(description, type, c);
      if( !solid.isValid() )   {
        except("VolumeBuilder","+++ Failed to create shape %s of type: %s",
               nam.c_str(), type.c_str());
      }
      printout(debug ? ALWAYS : DEBUG,"VolumeBuilder",
               "+++ Building shape  from XML: %s of type: %s",
               nam.c_str(), solid->IsA()->GetName());
      shapes.emplace(nam, std::make_pair(c,solid));
      continue;
    }
    except("VolumeBuilder","+++ Shape %s is already known to this builder unit. "
           "Cannot be overridden.", nam.c_str());
  }
  return shapes.size()-len;
}
 
std::size_t VolumeBuilder::buildVolumes(xml_h handle)    {
  std::size_t len = volumes.size();
  xml_elt_t  x_comp(0);
  for( xml_coll_t c(handle, _U(volume)); c; ++c )   {
    Solid       solid;
    xml_comp_t  x = c;
    std::string nam = x.attr<std::string>(_U(name));
    xml_attr_t attr = c.attr_nothrow(_U(build));
    if( attr )   {
      std::string build = c.attr<std::string>(attr);
      if( !buildMatch(build,buildType) )  {
        printout(INFO,"VolumeBuilder",
                 "+++ Volume %s does NOT match build requirements. [Ignored]",nam.c_str());
        continue;
      }
    }
    bool is_volume_with_shape = x.child(_U(shape),false) != 0 || c.attr_nothrow(_U(shape)) != 0;
    if( !is_volume_with_shape )  {
      is_volume_with_shape = x.child(_U(solid),false) != 0 || c.attr_nothrow(_U(solid)) != 0;
    }
    bool is_volume_with_type = c.attr_nothrow(_U(type)) != 0;
    bool is_assembly = (x.child(_U(assembly),false) != 0 || c.attr_nothrow(_U(assembly)) != 0);
    if ( is_assembly && ( is_volume_with_shape || is_volume_with_type) ) {
      printout(ERROR, "VolumeBuilder",
               "+++ Shape defined, but ignored for ASSEMBLY volume: %s %s",
               nam.c_str(), "[Inconsistent description]" );
    }
    if ( is_assembly || (!is_volume_with_shape && !is_volume_with_type) )  {
      Assembly  vol(nam);
      Solid     sol = vol.solid();
      xml_elt_t solid_handle(0);
      if( (solid_handle=x.child(_U(shape), false)) )  {
        shapes.emplace(nam, std::make_pair(solid_handle,sol));
      }
      placeDaughters(detector, vol, x);
      vol.setAttributes(description,x.regionStr(),x.limitsStr(),x.visStr());
      volumes.emplace(nam,std::make_pair(c,vol));
      printout(debug ? ALWAYS : DEBUG,"VolumeBuilder",
               "+++ Building assembly from XML: %-20s shape:%-24s vis:%s",
               nam.c_str(), vol->GetShape()->IsA()->GetName(), x.visStr().c_str());
      buildVolumes(c);
      continue;
    }
    //
    bool   is_sensitive = c.attr_nothrow(_U(sensitive));
    if( (attr=c.attr_nothrow(_U(type))) )   {
      std::string typ = c.attr<std::string>(attr);
      Volume      vol = xml::createVolume(description, typ, c);
      vol.setAttributes(description, x.regionStr(), x.limitsStr(), x.visStr());
      volumes.emplace(nam,std ::make_pair(c,vol));
      if( is_sensitive )   {
        vol.setSensitiveDetector(sensitive);
      }
      solid = vol.solid();
      printout(debug ? ALWAYS : DEBUG, "VolumeBuilder",
               "+++ Building volume   from XML: %-20s shape:%-24s vis:%s sensitive:%s",
               nam.c_str(), solid->IsA()->GetName(), x.visStr().c_str(),
               yes_no(is_sensitive));
      buildVolumes(c);
      continue;
    }
    
    if( (attr=c.attr_nothrow(_U(shape))) )   {
      std::string ref = c.attr<std::string>(attr);
      if( !(solid=getShape(ref)).isValid() ) continue;
    }
    else if( (attr=c.attr_nothrow(_U(solid))) )   {
      std::string ref = c.attr<std::string>(attr);
      if( !(solid=getShape(ref)).isValid() ) continue;
    }
    else if( (x_comp=x.child(_U(shape),false)) )  {
      if( !(solid=makeShape(x_comp)).isValid() ) continue;
    }
    else if( (x_comp=x.child(_U(solid),false)) )  {
      if( !(solid=makeShape(x_comp)).isValid() ) continue;
    }
 
    if( solid.isValid() )   {
      Material  mat = description.material(x.attr<std::string>(_U(material)));
      Volume    vol(nam, solid, mat);
      placeDaughters(detector, vol, x);
      vol.setAttributes(description,x.regionStr(),x.limitsStr(),x.visStr());
      volumes.emplace(nam,std::make_pair(c,vol));
      if( is_sensitive )   {
        vol.setSensitiveDetector(sensitive);
      }
      printout(debug ? ALWAYS : DEBUG, "VolumeBuilder",
               "+++ Building volume   from XML: %-20s shape:%-24s vis:%s sensitive:%s",
               nam.c_str(), solid->IsA()->GetName(), x.visStr().c_str(),
               yes_no(is_sensitive));
      buildVolumes(c);
      continue;
    }
    except("VolumeBuilder","+++ Failed to create volume %s - "
           "It is neither Volume nor assembly....", nam.c_str());
  }
  return volumes.size()-len;
}
 
void VolumeBuilder::_placeSingleVolume(DetElement parent, Volume vol, xml_h c)   {
  xml_attr_t attr = c.attr_nothrow(_U(logvol));
  if( !attr )   {
    attr = c.attr_nothrow(_U(volume));
  }
  if( !attr )   {
    except("VolumeBuilder","+++ The xml volume element has no 'logvol' or 'volume' attribute!");
  }
  std::string nam = c.attr<std::string>(attr);
  if( vol_veto.find(nam) != vol_veto.end() )   {
    return;
  }
  auto iv = volumes.find(nam);
  if( iv == volumes.end() )  {
    except("VolumeBuilder",
           "+++ Failed to locate volume %s [typo somewhere in the XML?]",
           nam.c_str());      
  }
  PlacedVolume pv;
  Volume daughter = (*iv).second.second;
  attr = c.attr_nothrow(_U(transformation));
  if( attr )   {
    std::string tr_nam = c.attr<std::string>(attr);
    auto it = transformations.find(tr_nam);
    if( it == transformations.end() )   {
      except("VolumeBuilder",
             "+++ Failed to locate name transformation %s [typo in the XML?]",
             nam.c_str());      
    }
    const Transform3D& tr = (*it).second.second;
    pv = vol.placeVolume(daughter, tr);
  }
  else  {
    Transform3D tr = xml::createTransformation(c);
    pv = vol.placeVolume(daughter, tr);
  }
  xml_attr_t attr_nam = c.attr_nothrow(_U(name));
  if( attr_nam )  {
    std::string phys_nam = c.attr<std::string>(attr_nam);
    pv->SetName(phys_nam.c_str());
  }
  attr = c.attr_nothrow(_U(element));
  if( attr && !parent.isValid() )  {
    except("VolumeBuilder",
           "+++ Failed to set DetElement placement for volume %s [Invalid parent]",
           nam.c_str());      
  }
  else if( attr )  {
    int    elt_id = parent.id();
    std::string elt = c.attr<std::string>(attr);
    attr = c.attr_nothrow(_U(id));
    if( attr )   {
      elt_id = c.attr<int>(attr);
      elt += c.attr<std::string>(attr);
    }
    DetElement de(parent, elt, elt_id);
    de.setPlacement(pv);
    placeDaughters(de, daughter, c);
  }
  else  {
    placeDaughters(parent, daughter, c);
  }
}
 
void VolumeBuilder::_placeParamVolumes(DetElement parent, Volume vol, xml_h c)   {
  xml_attr_t attr_tr, attr_elt, attr_nam;
  xml_h      x_phys = c.child(_U(physvol));
  xml_attr_t attr   = x_phys.attr_nothrow(_U(logvol));
  if( !attr )   {
    attr = x_phys.attr_nothrow(_U(volume));
  }
  if( !attr )   {
    except("VolumeBuilder","+++ The xml volume element has no 'logvol' or 'volume' attribute!");
  }
  std::string nam = x_phys.attr<std::string>(attr);
  if( vol_veto.find(nam) != vol_veto.end() )   {
    return;
  }
  auto iv = volumes.find(nam);
  if( iv == volumes.end() )  {
    except("VolumeBuilder",
           "+++ Failed to locate volume %s [typo somewhere in the XML?]",
           nam.c_str());      
  }
  attr_elt = c.attr_nothrow(_U(element));
  if( attr_elt && !parent.isValid() )  {
    except("VolumeBuilder",
           "+++ Failed to set DetElement placement for volume %s [Invalid parent]",
           nam.c_str());      
  }
  Volume daughter = (*iv).second.second;
  attr_tr = c.attr_nothrow(_U(transformation));
  Transform3D tr;
  if( attr_tr )   {
    std::string tr_nam = c.attr<std::string>(attr_tr);
    auto it = transformations.find(tr_nam);
    if( it == transformations.end() )   {
      except("VolumeBuilder",
             "+++ Failed to locate name transformation %s "
             "[typo somewhere in the XML?]",
             nam.c_str());      
    }
    tr = (*it).second.second;
  }
  else  {
    tr = xml::createTransformation(c);
  }
  Transform3D transformation(Position(0,0,0));
  int elt_id = -1;
  std::string elt, phys_nam;
  attr_nam = x_phys.attr_nothrow(_U(name));
  if( attr_nam )  {
    phys_nam = x_phys.attr<std::string>(_U(name))+"_%d";
  }
  if( attr_elt )  {
    elt_id = parent.id();
    elt = c.attr<std::string>(attr_elt);
  }
  int number = c.attr<int>(_U(number));
  printout(debug ? ALWAYS : DEBUG,"VolumeBuilder","+++ Mother:%s place volume %s  %d times.",
           vol.name(), daughter.name(), number);
  for(int i=0; i<number; ++i)    {
    PlacedVolume pv = vol.placeVolume(daughter, transformation);
    if( attr_nam )  {
      //pv->SetName(_toStd::String(i,phys_nam.c_str()).c_str());
    }
    if( attr_elt )  {
      DetElement de(parent,elt,elt_id);
      de.setPlacement(pv);
      //placeDaughters(de, daughter, c);
    }
    else  {
      //placeDaughters(parent, daughter, c);
    }
    transformation *= tr;
  }
}
 
std::size_t VolumeBuilder::load(xml_h element, const std::string& tag)  {
  std::size_t count = 0;
  for( xml_coll_t c(element,Unicode(tag)); c; ++c )   {
    std::string ref = c.attr<std::string>(_U(ref));
    std::unique_ptr<xml::DocumentHolder> doc(new xml::DocumentHolder(xml::DocumentHandler().load(element, c.attr_value(_U(ref)))));
    xml_h vols = doc->root();
    printout(debug ? ALWAYS : DEBUG, "VolumeBuilder",
             "++ Processing xml document %s.", doc->uri().c_str());
    included_docs[ref] = std::unique_ptr<xml::DocumentHolder>(doc.release());
    buildShapes(vols);
    buildTransformations(vols);
    buildVolumes(vols);
    ++count;
  }
  return count;
}
 
VolumeBuilder& VolumeBuilder::placeDaughters(Volume vol, xml_h handle)   {
  DetElement null_de;
  return placeDaughters(null_de, vol, handle);
}
 
VolumeBuilder& VolumeBuilder::placeDaughters(DetElement parent, Volume vol, xml_h handle)   {
  for( xml_coll_t c(handle,_U(physvol)); c; ++c )
    _placeSingleVolume(parent, vol, c);
  for( xml_coll_t c(handle,_U(paramphysvol)); c; ++c )
    _placeParamVolumes(parent, vol, c);
  return *this;
}
 
std::size_t VolumeBuilder::buildTransformations(Handle_t handle)   {
  std::size_t len = transformations.size();
  for( xml_coll_t c(handle,_U(transformation)); c; ++c )   {
    std::string nam = xml_comp_t(c).nameStr();
    transformations.emplace(nam,std::make_pair(c,xml::createTransformation(c)));
  }
  return transformations.size() - len;
}
 
dd4hep::PlacedVolume VolumeBuilder::placeDetector(Volume vol)    {
  return placeDetector(vol, x_det);
}
 
dd4hep::PlacedVolume VolumeBuilder::placeDetector(Volume vol, xml_h handle)    {
  xml_comp_t   x     = handle;
  xml_dim_t    x_pos = x_det.child(_U(position),false);
  xml_dim_t    x_rot = x_det.child(_U(rotation),false);
  xml_dim_t    x_tr  = x_det.child(_U(transformation),false);
  Volume       mother = description.pickMotherVolume(detector);
  PlacedVolume pv;
 
  if( x_tr )   {
    Transform3D tr = createTransformation(x_tr);
    pv = mother.placeVolume(vol, tr);
  }
  else if( x_pos && x_rot )   {
    Transform3D tr = createTransformation(x_det);
    pv = mother.placeVolume(vol, tr);
  }
  else if( x_pos )  {
    pv = mother.placeVolume(vol, Position(x_pos.x(0),x_pos.y(0),x_pos.z(0)));
  }
  else  {
    pv = mother.placeVolume(vol);
  }
  vol.setVisAttributes(description, x.visStr());
  vol.setLimitSet(description, x.limitsStr());
  vol.setRegion(description, x.regionStr());
  if( detector.isValid() )  {
    detector.setPlacement(pv);
  }
  return pv;
}
 
#endif