Detector/DetCRD/src/Other/ConcreteWall_v01.cpp

+#include "DD4hep/DetFactoryHelper.h"
+#include "XML/Layering.h"
+#include "XML/Utilities.h"
+#include "DDRec/DetectorData.h"
+#include "DDSegmentation/Segmentation.h"
+#include "DD4hep/Shapes.h"
+
+#define MYDEBUG(x) std::cout << __FILE__ << ":" << __LINE__ << ": " << x << std::endl;
+#define MYDEBUGVAL(x) std::cout << __FILE__ << ":" << __LINE__ << ": " << #x << ": " << x << std::endl;
+
+using dd4hep::rec::LayeredCalorimeterData;
+
+static dd4hep::Ref_t create_detector(dd4hep::Detector& theDetector,
+                                     xml_h e,
+                                     [[maybe_unused]] dd4hep::SensitiveDetector sens) {
+    xml_det_t x_det = e;
+    std::string det_name = x_det.nameStr();
+    std::string det_type = x_det.typeStr();
+    MYDEBUGVAL(det_name);
+    MYDEBUGVAL(det_type);
+
+    xml_dim_t pos(x_det.child(_U(position)));
+    xml_dim_t dim(x_det.child(_U(dimensions)));
+
+    dd4hep::DetElement sdet("det", 1771);
+    dd4hep::Material det_mat(theDetector.material("Concrete"));
+
+    dd4hep::Box box_shape(0.5 * dim.rmax(), 0.5 * dim.rmax(), 0.5 * dim.dz());
+    dd4hep::Tube hole_shape(0, dim.rmin(), 0.5 * dim.dz());
+
+    dd4hep::Transform3D transform_hole(
+        dd4hep::Rotation3D(),
+        dd4hep::Position(0, 0, 0)
+    );
+
+    dd4hep::SubtractionSolid solid = dd4hep::SubtractionSolid(box_shape, hole_shape, transform_hole);
+
+    dd4hep::Volume det_vol_with_hole(det_name + "_withHole", solid, det_mat);
+
+    dd4hep::Transform3D transform(
+        dd4hep::Rotation3D(),
+        dd4hep::Position(pos.x(), pos.y(), pos.z())
+    );
+
+    dd4hep::Transform3D transform_01(
+        dd4hep::Rotation3D(),
+        dd4hep::Position(pos.x(), pos.y(), -1 * pos.z())
+    );
+
+    dd4hep::PlacedVolume pv;
+    dd4hep::DetElement both_endcap(det_name, x_det.id());
+    dd4hep::Volume motherVol = theDetector.pickMotherVolume(both_endcap);
+    dd4hep::DetElement sdetA = sdet;
+    dd4hep::Ref_t(sdetA)->SetName((det_name + "_A").c_str());
+    dd4hep::DetElement sdetB = sdet.clone(det_name + "_B", 1772);
+
+    pv = motherVol.placeVolume(det_vol_with_hole, transform);
+
+    both_endcap.setPlacement(pv);
+    both_endcap.add(sdetA);
+    both_endcap.add(sdetB);
+
+    pv = motherVol.placeVolume(det_vol_with_hole, transform_01);
+    sdetB.setPlacement(pv);
+
+    MYDEBUG("create_detector DONE. ");
+    return both_endcap;
+}
+DECLARE_DETELEMENT(ConcreteWall_v01, create_detector)

Detector/DetCRD/src/Other/Lumical_v01_geo_beampipe.cpp

+//==========================================================================
+//Lumical Detector Construction
+//--------------------------------------------------------------------------
+// 
+// Author: Sun Xingyang , NJU
+//==========================================================================
+#include "DD4hep/DetFactoryHelper.h"
+#include "DDRec/DetectorData.h"
+#include "XML/Utilities.h"
+#include "cmath"
+#include "DDSegmentation/BitField64.h"
+#include "DDSegmentation/TiledLayerGridXY.h"
+#include "DDSegmentation/Segmentation.h"
+#include "DDSegmentation/MultiSegmentation.h"
+#include <vector>
+#include <iostream>
+#include "XML/Layering.h"
+
+
+using namespace std;
+using namespace dd4hep;
+using namespace dd4hep::detail;
+using dd4hep::Readout;
+using dd4hep::Position;
+using dd4hep::BUILD_ENVELOPE;
+using dd4hep::Box;
+using dd4hep::DetElement;
+using dd4hep::Detector;
+using dd4hep::IntersectionSolid;
+using dd4hep::Material;
+using dd4hep::PlacedVolume;
+using dd4hep::Ref_t;
+using dd4hep::Rotation3D;
+using dd4hep::RotationZ;
+using dd4hep::RotationZYX;
+using dd4hep::SensitiveDetector;
+using dd4hep::Transform3D;
+using dd4hep::Trapezoid;
+using dd4hep::Tube;
+using dd4hep::Volume;
+using dd4hep::_toString;
+
+using dd4hep::rec::LayeredCalorimeterData;
+
+
+static Ref_t create_detector(Detector& description, xml_h e, SensitiveDetector sens) {
+    std::cout << "This is the Lumical_v02:"  << std::endl;
+
+    xml_det_t x_det = e;
+    string det_name = x_det.nameStr();
+    DetElement cal(det_name, x_det.id());
+
+// --- create an envelope volume and position it into the world ---------------------
+    Volume envelope = dd4hep::xml::createPlacedEnvelope( description, e, cal );
+    dd4hep::xml::setDetectorTypeFlag( e, cal ) ;
+    if( description.buildType() == BUILD_ENVELOPE ) return cal;
+    envelope.setVisAttributes(description, x_det.visStr());
+    PlacedVolume pv;
+
+    DetElement beampipe1_inner_DE(cal,"beampipe_Be_inner",x_det.id());
+    DetElement beampipe1_outter_DE(cal,"beampipe_Be_outter",x_det.id());
+    DetElement beampipe2_inner_DE(cal,"beampipe_Al_inner",x_det.id());
+    DetElement beampipe2_outter_DE(cal,"beampipe_Al_outter",x_det.id());
+    DetElement runway_DE(cal,"runway",x_det.id());
+
+    for(int kz=1;kz>=-1;kz-=2){
+/////////////////////////////////////////////////////////////////
+//build Be beampipe
+        xml_comp_t component_beampipe1_inner = x_det.child(_Unicode(beampipe_Be_inner));
+        Material fBe = description.material(component_beampipe1_inner.materialStr());
+        xml_dim_t pos_beampipe_Be = component_beampipe1_inner.position();
+
+        xml_comp_t component_beampipe1_outter = x_det.child(_Unicode(beampipe_Be_outter));
+    
+        Tube beampipe_Be_inner(component_beampipe1_inner.rmin(),component_beampipe1_inner.rmax(),component_beampipe1_inner.z()*0.5,component_beampipe1_inner.phi1(),component_beampipe1_inner.phi2());
+    
+        Volume beampipe_Be_inner_Vol("beampipe_Be_inner", beampipe_Be_inner,fBe);
+        beampipe_Be_inner_Vol.setVisAttributes(description, component_beampipe1_inner.visStr());
+        Transform3D transform_beampipe_Be(RotationZYX(0,0,0), Translation3D(pos_beampipe_Be.x(), pos_beampipe_Be.y() , kz*pos_beampipe_Be.z()));
+        envelope.placeVolume(beampipe_Be_inner_Vol, transform_beampipe_Be);
+
+        Tube beampipe_Be_outter(component_beampipe1_outter.rmin(),component_beampipe1_outter.rmax(),component_beampipe1_outter.z()*0.5,component_beampipe1_outter.phi1(),component_beampipe1_outter.phi2());
+        Volume beampipe_Be_outter_Vol("beampipe_Be_outter", beampipe_Be_outter,fBe);
+        beampipe_Be_outter_Vol.setVisAttributes(description, component_beampipe1_outter.visStr());
+        envelope.placeVolume(beampipe_Be_outter_Vol, transform_beampipe_Be);
+    
+//////////////////////////////////////////////////////////////////////////////////////////////////////////
+//build Al beampipe
+        xml_comp_t component_beampipe2_inner = x_det.child(_Unicode(beampipe_Al_inner));
+        Material fAl = description.material(component_beampipe2_inner.materialStr());
+        xml_dim_t pos_beampipe_Al = component_beampipe2_inner.position();
+
+        xml_comp_t component_beampipe2_outter = x_det.child(_Unicode(beampipe_Al_outter));
+    
+
+        Tube beampipe_Al_inner(component_beampipe2_inner.rmin(),component_beampipe2_inner.rmax(),component_beampipe2_inner.z()*0.5,component_beampipe2_inner.phi1(),component_beampipe2_inner.phi2());
+        Volume beampipe_Al_inner_Vol("beampipe_Al_inner", beampipe_Al_inner,fAl);
+        beampipe_Al_inner_Vol.setVisAttributes(description, component_beampipe2_inner.visStr());
+        Transform3D transform_beampipe_Al(RotationZYX(0,0,0), Translation3D(pos_beampipe_Al.x(), pos_beampipe_Al.y() , kz*pos_beampipe_Al.z()));
+        envelope.placeVolume(beampipe_Al_inner_Vol, transform_beampipe_Al);
+
+        Tube beampipe_Al_outter(component_beampipe2_outter.rmin(),component_beampipe2_outter.rmax(),component_beampipe2_outter.z()*0.5,component_beampipe2_outter.phi1(),component_beampipe2_outter.phi2());
+        Volume beampipe_Al_outter_Vol("beampipe_Al_outter", beampipe_Al_outter,fAl);
+        beampipe_Al_outter_Vol.setVisAttributes(description, component_beampipe2_outter.visStr());
+        envelope.placeVolume(beampipe_Al_outter_Vol, transform_beampipe_Al);
+//////////////////////////////////////////////////////////////////////
+//build runway
+
+        xml_comp_t component_runway = x_det.child(_Unicode(runway));
+    
+        xml_dim_t pos_runway = component_runway.position();
+        for(int kx = -1;kx<=1;kx+=2){
+            double phi0=90*deg-kx*90*deg;
+            Transform3D transform_runway(RotationZYX(90*deg,0,0), Translation3D(-kx*pos_runway.x(), pos_runway.y() , kz*pos_runway.z()));
+
+            Tube runway(component_runway.rmin(),component_runway.rmax(),component_runway.z()*0.5,phi0,phi0+180*deg);
+            Volume runway_Vol("runway", runway,fAl);
+            runway_Vol.setVisAttributes(description, component_runway.visStr());
+            envelope.placeVolume(runway_Vol, transform_runway);                                                                                                                                 
+        }
+///////////////////////////////////////////////////////////////////////////////////////
+//build beampipe between flange
+    
+    for(xml_coll_t c(x_det,_U(beampipe));c;c++){
+        int layer_num=1;
+        xml_comp_t   x_layer = c;
+        int count = 0;
+        for(xml_coll_t k(x_layer,_U(slice)); k; k++)  {
+            string module_name = _toString(0,"_module%d")+_toString(0,"_stave%d");
+            int slice_number = 0;
+            xml_comp_t x_slice = k;
+            string layer_name      = det_name+module_name+_toString(layer_num,"_layer%d");
+            for(int kx = -1;kx<=1;kx+=2){
+                double phi0=90*deg-kx*90*deg;
+                
+                string slice_name      = layer_name+_toString(slice_number,"_slice%d");
+
+                DetElement slice(slice_name,_toString(slice_number,"_slice%d"),x_det.id());
+                Material slice_material  = description.material(x_slice.materialStr());
+
+                if(count==0||count==2){
+                    Volume slice_vol(slice_name,Tube(x_slice.rmin(),x_slice.rmax(),x_slice.z()/2,phi0,phi0+90*deg*(count+2)),slice_material);
+                    slice_vol.setVisAttributes(description,x_slice.visStr());
+                    Transform3D transform_beampipe(RotationZYX(90*deg,0,0), Translation3D(-kx*x_slice.position().x(),x_slice.position().y() , kz*x_slice.position().z()));
+                    PlacedVolume slice_phv = envelope.placeVolume(slice_vol,transform_beampipe);
+                    slice_phv.addPhysVolID("side",kz).addPhysVolID("module",0).addPhysVolID("layer",0  ).addPhysVolID("slice",layer_num);
+                    //std::cout<<"side:"<<kz<<"module:"<<0<<"layer:"<<layer_num<<"slice:"<<layer_num<<"\n";
+                    slice.setPlacement(slice_phv);
+                    slice_number++;
+                }
+                else if (count==1){
+                    
+                    double rmin1 = x_slice.rmin1();
+                    double rmax1 = x_slice.rmax1();
+                    double rmin2 = x_slice.rmin2();
+                    double rmax2 = x_slice.rmax2();
+                    if(kz==-1){
+                        double r1 = rmin1;
+                        rmin1 = rmin2;
+                        rmin2 = r1;
+                        double r2 = rmax1;
+                        rmax1 = rmax2;
+                        rmax2 = r2;
+                    }
+                    Volume slice_vol(slice_name,ConeSegment(x_slice.z()/2,rmin1,rmax1,rmin2,rmax2,phi0,phi0+180*deg),slice_material);
+                    slice_vol.setVisAttributes(description,x_slice.visStr());
+                    Transform3D transform_beampipe(RotationZYX(90*deg,0,0), Translation3D(-kx*x_slice.position().x(),x_slice.position().y() , kz*x_slice.position().z()));
+                    PlacedVolume slice_phv = envelope.placeVolume(slice_vol,transform_beampipe);
+                    slice_phv.addPhysVolID("side",kz).addPhysVolID("module",0).addPhysVolID("layer",0  ).addPhysVolID("slice",layer_num);
+                    //std::cout<<"side:"<<kz<<"module:"<<0<<"layer:"<<layer_num<<"slice:"<<layer_num<<"\n";
+                    slice.setPlacement(slice_phv);
+                    slice_number++;
+                }
+                
+            }
+            count++;
+        }
+        layer_num++;
+    }
+    }
+    return cal;
+}
+
+DECLARE_DETELEMENT(Lumical_v01_standalone, create_detector)

Detector/DetCRD/src/Other/OtherDetectorHelpers.h

+#ifndef Other_Helpers_hh
+#define Other_Helpers_hh 1
+
+#include <iostream>
+#include <map>
+#include <stdexcept>
+
+namespace CEPC {
+  typedef enum {
+    kCenter                     = 0,
+    kCenterSide                 = 1,
+    kWaist                      = 2,
+    kFatWaist                   = 3,
+    kCrotch                     = 4,
+    kCrotchAsymUp               = 5,
+    kCrotchAsymDn               = 6,
+    kLegs                       = 7,
+    kFlareLegUp                 = 8,
+    kFlareLegDn                 = 9,
+    kRunway               = 10
+  } ECrossType;
+  
+  inline ECrossType getCrossType( std::string const & type) {
+    std::map< std::string, CEPC::ECrossType > CrossTypes;
+    CrossTypes["Center"]                = CEPC::kCenter;
+    CrossTypes["CenterSide"]            = CEPC::kCenterSide;
+    CrossTypes["Waist"]                 = CEPC::kWaist;
+    CrossTypes["FatWaist"]              = CEPC::kFatWaist;
+    CrossTypes["Crotch"]                = CEPC::kCrotch;
+    CrossTypes["CrotchAsymUp"]          = CEPC::kCrotchAsymUp;
+    CrossTypes["CrotchAsymDn"]          = CEPC::kCrotchAsymDn;
+    CrossTypes["Legs"]                  = CEPC::kLegs;
+    CrossTypes["FlareLegUp"]            = CEPC::kFlareLegUp;
+    CrossTypes["FlareLegDn"]            = CEPC::kFlareLegDn;
+    CrossTypes["Runway"]                = CEPC::kRunway;
+
+    std::map < std::string, CEPC::ECrossType>::const_iterator it = CrossTypes.find(type);
+    if ( it == CrossTypes.end() ) {
+      std::string ms = "Unknown Crossing Type for this geometry " + type;
+      throw std::runtime_error(ms.c_str());
+    }
+    return it->second;
+  }
+}
+#endif // Other_Helpers_hh

Detector/DetCRD/src/Other/ParaffinEndcap_v01.cpp

+#include "DD4hep/DetFactoryHelper.h"
+#include "XML/Layering.h"
+#include "XML/Utilities.h"
+#include "DDRec/DetectorData.h"
+#include "DDSegmentation/Segmentation.h"
+
+#define MYDEBUG(x) std::cout << __FILE__ << ":" << __LINE__ << ": " << x << std::endl;
+#define MYDEBUGVAL(x) std::cout << __FILE__ << ":" << __LINE__ << ": " << #x << ": " << x << std::endl;
+
+using dd4hep::rec::LayeredCalorimeterData;
+static dd4hep::Ref_t create_detector(dd4hep::Detector& theDetector,
+                                     xml_h e,
+                                     dd4hep::SensitiveDetector sens) {
+
+    xml_det_t x_det = e;
+
+    std::string det_name = x_det.nameStr();
+    std::string det_type = x_det.typeStr();
+    MYDEBUGVAL(det_name);
+    MYDEBUGVAL(det_type);
+    xml_dim_t   pos    (x_det.child(_U(position)));
+    xml_dim_t   dim    (x_det.child(_U(dimensions)));
+
+
+    dd4hep::DetElement sdet("det",1770);
+
+    dd4hep::Material det_mat(theDetector.material("ParaffinWax"));
+    dd4hep::Volume det_vol(det_name+"_vol", dd4hep::Tube(dim.rmin(), dim.rmax(), dim.dz()), det_mat);
+
+    dd4hep::Transform3D transform(dd4hep::Rotation3D(),
+                                  dd4hep::Position(pos.x(),pos.y(),pos.z()));
+    dd4hep::Transform3D transform_01(dd4hep::Rotation3D(),
+                                  dd4hep::Position(pos.x(),pos.y(),-1*pos.z()));
+
+
+    //Create caloData object to extend driver with data required for reconstruction
+
+    dd4hep::PlacedVolume pv;
+    dd4hep::DetElement both_endcap(det_name, x_det.id());
+    dd4hep::Volume motherVol = theDetector.pickMotherVolume(both_endcap);
+    dd4hep::DetElement sdetA = sdet;
+    dd4hep::Ref_t(sdetA)->SetName((det_name+"_A").c_str());
+    dd4hep::DetElement sdetB = sdet.clone(det_name+"_B",1769);
+    dd4hep::Assembly assembly("assembly");
+    pv = assembly.placeVolume(det_vol,transform);
+
+    sdetA.setPlacement(pv);
+
+    pv = assembly.placeVolume(det_vol,transform_01);
+
+    sdetB.setPlacement(pv);
+
+    pv = motherVol.placeVolume(assembly);
+    both_endcap.setPlacement(pv);
+    both_endcap.add(sdetA);
+    both_endcap.add(sdetB);
+
+    MYDEBUG("create_detector DONE. ");
+    return both_endcap;
+
+
+}
+
+DECLARE_DETELEMENT(ParaffinEndcap_v01, create_detector)

Detector/DetCRD/src/Tracker/ITK_EndCap_v01.cpp

+#include <DD4hep/Detector.h>
+#include "DD4hep/DetFactoryHelper.h"
+#include "XML/Utilities.h"
+#include "DDRec/Surface.h"
+#include "DetIdentifier/CEPCDetectorData.h"
+#include "Math/AxisAngle.h"
+#include <map>
+
+using namespace dd4hep;
+
+static Ref_t create_detector(Detector& description, xml_h e, SensitiveDetector sens)
+{
+  xml_det_t x_det = e;
+  Material air = description.air();
+  int det_id = x_det.id();
+  std::string name = x_det.nameStr();
+  bool reflect = x_det.reflect(false);
+  DetElement tracker(name, det_id);
+
+  Volume envelope = createPlacedEnvelope(description, e, tracker);
+  setDetectorTypeFlag(e, tracker);
+  if (description.buildType() == BUILD_ENVELOPE)
+    return tracker;
+  envelope = envelope.setVisAttributes(description.visAttributes("SeeThrough"));
+
+  if (x_det.hasChild(_U(sensitive)))
+  {
+    xml_dim_t sd_typ = x_det.child(_U(sensitive));
+    sens.setType(sd_typ.typeStr());
+  }
+  else
+  {
+    sens.setType("tracker");
+  }
+  std::cout << " ** building ITK_EndCap_v01 ... " << sens.type() << std::endl;
+
+  dd4hep::rec::MultiRingsZDiskData* diskData = new dd4hep::rec::MultiRingsZDiskData;
+
+  const xml::Component supports = x_det.child("support");
+  const xml::Component sensor   = x_det.child("sensor");
+
+  const xml::Component layers_xml = x_det.child("layers");
+  for (xml_coll_t layer(layers_xml, "layer"); layer; ++layer)
+  {
+    dd4hep::rec::MultiRingsZDiskData::LayerLayout disk;
+    //id="0" z="505*mm" dz="SiliconThickness*2 + SupportThickness" inner_r="81.5*mm" outer_r="242.5*mm" vis="SeeThrough"
+    const auto layer_id = layer.attr<std::string>("id");
+    //const auto dz = layer.attr<double>("dz");
+    const auto inner_r = layer.attr<double>("inner_r");
+    const auto outer_r = layer.attr<double>("outer_r");
+    const auto phi0 = layer.attr<double>("phi0");
+    const auto layer_vis = layer.attr<std::string>("vis");
+    const auto z = layer.attr<double>("z");
+    std::string layer_name = "layer" + layer_id;
+
+    double SiliconThickness = 0;
+    double SupportThickness = 0;
+    for (xml_coll_t sensor_layer(sensor, "slice"); sensor_layer; ++sensor_layer)
+    {
+      const auto slice_thickness = sensor_layer.attr<double>("thickness");
+      SiliconThickness += slice_thickness;
+    }
+    for (xml_coll_t support(supports, "slice"); support; ++support)
+    {
+      const auto slice_thickness = support.attr<double>("thickness");
+      SupportThickness += slice_thickness;
+    }
+    const auto dz = 2*SiliconThickness + SupportThickness;
+
+    Tube layer_tube(inner_r, outer_r, dz / 2.0, 0.0, 2 * M_PI);
+    Volume layer_vol(layer_name + "P", layer_tube, air);
+    Volume layerNeg_vol(layer_name + "N", layer_tube, air);
+    DetElement layer_det(layer_name + "P", det_id);
+    DetElement layerNeg_det(layer_name + "N", det_id);
+    layer_vol.setVisAttributes(description.visAttributes(layer_vis));
+    layerNeg_vol.setVisAttributes(description.visAttributes(layer_vis));
+
+    // populate support
+    double support_z = -SupportThickness / 2.0;
+    //const xml::Component supports = x_det.child("support");
+    for (xml_coll_t support(supports, "slice"); support; ++support)
+    {
+      const auto support_name = support.attr<std::string>("name");
+      const auto support_material = support.attr<std::string>("material");
+      const auto support_thickness = support.attr<double>("thickness");
+      const auto support_vis = support.attr<std::string>("vis");
+      std::string support_vol_name = layer_name + "_" + support_name;
+      Tube support_tube(inner_r, outer_r, support_thickness / 2.0, 0.0, 2 * M_PI);
+      Volume support_vol(support_vol_name, support_tube, description.material(support_material));
+      DetElement support_det(support_vol_name, det_id);
+      DetElement supportNeg_det(support_vol_name + "N", det_id);
+      support_vol = support_vol.setVisAttributes(description.visAttributes(support_vis));
+      support_det.setPlacement(layer_vol.placeVolume(support_vol, Position(0, 0, support_z + support_thickness / 2.0)));
+      supportNeg_det.setPlacement(layerNeg_vol.placeVolume(support_vol, Position(0, 0, - support_z - support_thickness / 2.0)));
+      support_z += support_thickness;
+      layer_det.add(support_det);
+      layerNeg_det.add(supportNeg_det);
+      rec::Vector3D u(1., 0., 0.);
+      rec::Vector3D v(0., 1., 0.);
+      rec::Vector3D n(0., 0., 1.);
+      rec::VolPlane surf(support_vol, rec::SurfaceType::Helper, support_thickness / 2.0, support_thickness / 2.0, u, v,
+                         n);
+      rec::volSurfaceList(support_det)->push_back(surf);
+      rec::volSurfaceList(supportNeg_det)->push_back(surf);
+    }
+
+    // populate sensor
+    for (xml_coll_t ring(layer, "ring"); ring; ++ring)
+    {
+      const auto ring_id = ring.attr<std::string>("id");
+      const auto ring_inner_r = ring.attr<double>("inner_r");
+      const auto ring_outer_r = ring.attr<double>("outer_r");
+      const auto module_dr = ring.attr<double>("module_dr");
+      const auto module_dphi = ring.attr<double>("module_dphi");
+      const auto nmodule = ring.attr<double>("nmodule");
+      const auto vis = ring.attr<std::string>("vis");
+
+      std::string ring_vol_name = layer_name + "_ring" + ring_id;
+      Tube ring_tube(ring_inner_r, ring_outer_r, SiliconThickness / 2.0, 0.0, 2 * M_PI);
+      Volume ringPosF_vol(ring_vol_name + "PF", ring_tube, air);
+      Volume ringPosR_vol(ring_vol_name + "PR", ring_tube, air);
+      Volume ringNegF_vol(ring_vol_name + "NF", ring_tube, air);
+      Volume ringNegR_vol(ring_vol_name + "NR", ring_tube, air);
+      DetElement ringPosF_det(ring_vol_name + "PF", det_id);
+      DetElement ringPosR_det(ring_vol_name + "PR", det_id);
+      DetElement ringNegF_det(ring_vol_name + "NF", det_id);
+      DetElement ringNegR_det(ring_vol_name + "NR", det_id);
+      ringPosF_vol.setVisAttributes(description.visAttributes(vis));
+      ringPosR_vol.setVisAttributes(description.visAttributes(vis));
+      ringNegF_vol.setVisAttributes(description.visAttributes(vis));
+      ringNegR_vol.setVisAttributes(description.visAttributes(vis));
+
+      // populate sensor
+      Box sensor_box(module_dr / 2.0, module_dphi / 2.0, SiliconThickness / 2.0);
+      std::string sensor_name = ring_vol_name + "_petal";
+      Volume sensor_vol(sensor_name, sensor_box, air);
+      DetElement sensor_det(sensor_name, det_id);
+      sensor_vol = sensor_vol.setVisAttributes(description.visAttributes(vis));
+
+      double sensitive_thickness = 0;
+      double glue_thickness      = 0;
+      double service_thickness   = 0;
+      //const xml::Component sensor = x_det.child("sensor");
+      double sensor_z = -SiliconThickness / 2.0;
+      for (xml_coll_t sensor_layer(sensor, "slice"); sensor_layer; ++sensor_layer)
+      {
+        const auto sensor_layer_name = sensor_layer.attr<std::string>("name");
+        const auto sensor_layer_material = sensor_layer.attr<std::string>("material");
+        const auto sensor_layer_thickness = sensor_layer.attr<double>("thickness");
+        const auto sensor_layer_vis = sensor_layer.attr<std::string>("vis");
+        auto is_sensitive = sensor_layer.hasAttr(_U(sensitive));
+        std::string sensor_layer_vol_name = sensor_name + "_" + sensor_layer_name;
+        Box sensor_layer_box(module_dr / 2.0, module_dphi / 2.0, sensor_layer_thickness / 2.0);
+        Volume sensor_layer_vol(sensor_layer_vol_name, sensor_layer_box, description.material(sensor_layer_material));
+        DetElement sensor_layer_det(sensor_layer_vol_name, det_id);
+        sensor_layer_vol = sensor_layer_vol.setVisAttributes(description.visAttributes(sensor_layer_vis));
+        rec::SurfaceType surf_type;
+        if (is_sensitive)
+        {
+          sensor_layer_vol = sensor_layer_vol.setSensitiveDetector(sens);
+          surf_type = rec::SurfaceType(rec::SurfaceType::Sensitive,rec::SurfaceType::Plane);
+	  sensitive_thickness += sensor_layer_thickness;
+        }
+        else
+        {
+          surf_type = rec::SurfaceType(rec::SurfaceType::Helper,rec::SurfaceType::Plane);
+	  if (sensitive_thickness==0) glue_thickness    += sensor_layer_thickness;
+          else                        service_thickness += sensor_layer_thickness;
+        }
+        sensor_layer_det.setPlacement(
+          sensor_vol.placeVolume(sensor_layer_vol, Position(0, 0, sensor_z + sensor_layer_thickness / 2.0)));
+        sensor_z += sensor_layer_thickness;
+
+        sensor_det.add(sensor_layer_det);
+        rec::Vector3D u(0.,-1., 0.);
+        rec::Vector3D v(1., 0., 0.);
+        rec::Vector3D n(0., 0., 1.);
+        rec::VolPlane surf(sensor_layer_vol, surf_type, sensor_layer_thickness / 2.0,
+                           sensor_layer_thickness / 2.0, u, v,
+                           n);
+        rec::volSurfaceList(sensor_layer_det)->push_back(surf);
+      }
+
+      PlacedVolume pv;
+      // place all the sensors into ring
+      double r_offset = ring_inner_r + module_dr / 2.0;
+      for (int i = 0; i < nmodule; ++i)
+      {
+        double angle = phi0 + i * 2 * M_PI / nmodule;
+	double rotated_x = r_offset * cos(angle);
+	double rotated_y = r_offset * sin(angle);
+        auto transform = Transform3D(RotationZ(angle), Position(rotated_x, rotated_y, 0));
+
+        DetElement negative_even_sensor_det = i > 0 ? sensor_det.clone(ring_vol_name + "_petalN" + std::to_string(2 * i)) : sensor_det;
+	pv = ringNegF_vol.placeVolume(sensor_vol, transform).addPhysVolID("module", 2 * i);
+        negative_even_sensor_det.setPlacement(pv);
+        ringNegF_det.add(negative_even_sensor_det);
+
+        transform = Transform3D(RotationZYX(-angle, 0, M_PI), Position(rotated_x, rotated_y, 0));
+	DetElement positive_even_sensor_det = sensor_det.clone(ring_vol_name + "_petalP" + std::to_string(2 * i));
+        pv = ringPosF_vol.placeVolume(sensor_vol, transform).addPhysVolID("module", 2 * i);
+        positive_even_sensor_det.setPlacement(pv);
+        ringPosF_det.add(positive_even_sensor_det);
+
+	angle += M_PI / nmodule;
+        rotated_x = r_offset * cos(angle);
+        rotated_y = r_offset * sin(angle);
+	transform = Transform3D(RotationZ(angle), Position(rotated_x, rotated_y, 0));
+
+	DetElement positive_odd_sensor_det = sensor_det.clone(ring_vol_name + "_petalP" + std::to_string(2 * i));
+        pv = ringPosR_vol.placeVolume(sensor_vol, transform).addPhysVolID("module", 2 * i + 1);
+        positive_odd_sensor_det.setPlacement(pv);
+        ringPosR_det.add(positive_odd_sensor_det);
+
+	transform = Transform3D(RotationZYX(-angle, 0, M_PI), Position(rotated_x, rotated_y, 0));
+	DetElement negative_odd_sensor_det = sensor_det.clone(ring_vol_name + "_petalN" + std::to_string(2 * i));
+	pv = ringNegR_vol.placeVolume(sensor_vol, transform).addPhysVolID("module", 2 * i + 1);
+        negative_odd_sensor_det.setPlacement(pv);
+        ringNegR_det.add(negative_odd_sensor_det);
+      }
+
+      // place ring into layer
+      pv = layer_vol.placeVolume(ringPosR_vol, Position(0, 0, +(SupportThickness + SiliconThickness) / 2.0));
+      pv = pv.addPhysVolID("sensor", std::stoi(ring_id));
+      ringPosR_det.setPlacement(pv);
+      layer_det.add(ringPosR_det);
+
+      pv = layer_vol.placeVolume(ringPosF_vol, Position(0, 0, -(SupportThickness + SiliconThickness) / 2.0));
+      pv = pv.addPhysVolID("sensor", std::stoi(ring_id));
+      ringPosF_det.setPlacement(pv);
+      layer_det.add(ringPosF_det);
+
+      pv = layerNeg_vol.placeVolume(ringNegR_vol, Position(0, 0, -(SupportThickness + SiliconThickness) / 2.0));
+      pv = pv.addPhysVolID("sensor", std::stoi(ring_id));
+      ringNegR_det.setPlacement(pv);
+      layerNeg_det.add(ringNegR_det);
+
+      pv = layerNeg_vol.placeVolume(ringNegF_vol, Position(0, 0, +(SupportThickness + SiliconThickness) / 2.0));
+      pv = pv.addPhysVolID("sensor", std::stoi(ring_id));
+      ringNegF_det.setPlacement(pv);
+      layerNeg_det.add(ringNegF_det);
+      // rotate and reflect ring
+      // fucd: error while use Rotation3D(1, 0, 0, 0, 1, 0, 0, 0, -1)
+      // Geant4VolumeManager INFO  +++   Bad volume Geant4 Path
+      /*
+      std::string reflect_ring_name = ring_vol_name + "_reflect";
+      auto reflect_ring_det = ring_det.clone(reflect_ring_name, det_id);
+      reflect_ring_det.setPlacement(layer_vol.placeVolume(
+        ring_vol, Transform3D(RotationZ(M_PI / nmodule) * Rotation3D(1, 0, 0, 0, 1, 0, 0, 0, -1) ,
+                              Position(0, 0, -(SupportThickness + SiliconThickness) / 2.0)))
+				    .addPhysVolID("sensor", std::stoi(ring_id)).addPhysVolID("face", 1));
+      layer_det.add(reflect_ring_det);
+      */
+      // fucd: also error
+      /*
+      std::pair<DetElement,Volume> reflected_ring = ring_det.reflect(ring_vol_name + "_reflect");
+      auto pv = layer_vol.placeVolume(reflected_ring.second, Position(0, 0, -(SupportThickness + SiliconThickness) / 2.0))
+	                 .addPhysVolID("sensor", std::stoi(ring_id))
+	                 .addPhysVolID("face", 1);
+      reflected_ring.first.setPlacement(pv);
+      layer_det.add(reflected_ring.first);
+      */
+      dd4hep::rec::MultiRingsZDiskData::Ring ringData;
+      ringData.petalNumber        = 2 * nmodule;
+      ringData.sensorsPerPetal    = 1;
+      ringData.phi0               = phi0;
+      ringData.phiOffsetOdd       = 2 * M_PI / nmodule;
+      ringData.distance           = ring_inner_r;
+      ringData.widthInner         = module_dphi;
+      ringData.widthOuter         = module_dphi;
+      ringData.length             = module_dr;
+      ringData.thicknessSensitive = SiliconThickness - glue_thickness - service_thickness;
+      ringData.thicknessGlue      = glue_thickness;
+      ringData.thicknessService   = service_thickness;
+      disk.rings.push_back(ringData);
+    }
+
+    // put layer into envelope
+    layer_det.setPlacement(envelope.placeVolume(layer_vol, Position(0, 0, z))
+			   .addPhysVolID("layer", std::stoi(layer_id)).addPhysVolID("side", 1));
+    tracker.add(layer_det);
+    // copy layer_vol and put reflect
+    if (reflect)
+    {
+      /*
+      std::string reflect_layer_name = layer_name + "_reflect";
+      auto reflect_layer_det = layer_det.clone(reflect_layer_name, det_id);
+      reflect_layer_det.setPlacement(
+        envelope.placeVolume(layer_vol, Transform3D(Rotation3D(1, 0, 0, 0, 1, 0, 0, 0, -1), Position(0, 0, -z))).addPhysVolID("side", -1).
+                 addPhysVolID("layer", std::stoi(layer_id)));
+      tracker.add(reflect_layer_det);
+      */
+      /*
+      std::pair<DetElement,Volume> reflected_layer = layer_det.reflect(layer_name + "_reflect");
+      auto pv = envelope.placeVolume(reflected_layer.second, Position(0, 0, -z))
+	                .addPhysVolID("side", -1).addPhysVolID("layer", std::stoi(layer_id));
+      reflected_layer.first.setPlacement(pv);
+      tracker.add(reflected_layer.first);
+      */
+      layerNeg_det.setPlacement(envelope.placeVolume(layerNeg_vol, Position(0, 0, -z))
+				.addPhysVolID("layer", std::stoi(layer_id)).addPhysVolID("side", -1));
+      tracker.add(layerNeg_det);
+    }
+
+    disk.typeFlags[dd4hep::rec::MultiRingsZDiskData::SensorType::DoubleSided] = 1;
+    disk.typeFlags[dd4hep::rec::MultiRingsZDiskData::SensorType::Pixel]       = 1;
+    disk.alphaPetal       = 0;
+    disk.zPosition        = z;
+    disk.zOffsetSupport   = 0;
+    disk.rminSupport      = inner_r;
+    disk.rmaxSupport      = outer_r;
+    disk.thicknessSupport = SupportThickness;
+    diskData->layers.push_back(disk);
+  }
+
+  std::cout << (*diskData) << std::endl;
+  tracker.addExtension<dd4hep::rec::MultiRingsZDiskData>(diskData);
+
+  if (x_det.hasAttr(_U(combineHits)))
+  {
+    tracker.setCombineHits(x_det.attr<bool>(_U(combineHits)), sens);
+  }
+
+  return tracker;
+}
+
+DECLARE_DETELEMENT(ITK_EndCap_v01, create_detector)

Detector/DetCRD/src/Tracker/SiTrackerComposite_v01_geo.cpp

+//====================================================================
+//  cepcgeo - CEPC silicon detector models in DD4hep 
+//--------------------------------------------------------------------
+//  Chengdong FU, IHEP
+//  email: fucd@ihep.ac.cn
+//  $Id$
+//====================================================================
+#include "DD4hep/DetFactoryHelper.h"
+#include "DD4hep/DD4hepUnits.h"
+#include "DD4hep/DetType.h"
+#include "DD4hep/Printout.h"
+#include "DDRec/Surface.h"
+#include "DDRec/DetectorData.h"
+#include "XML/Utilities.h"
+#include <cmath>
+
+#include "DetIdentifier/CEPCDetectorData.h"
+
+using namespace std;
+
+using dd4hep::Box;
+using dd4hep::Tube;
+using dd4hep::DetElement;
+using dd4hep::Material;
+using dd4hep::Position;
+using dd4hep::RotationY;
+using dd4hep::RotationZ;
+using dd4hep::RotationZYX;
+using dd4hep::Transform3D;
+using dd4hep::Rotation3D;
+using dd4hep::Volume;
+using dd4hep::_toString;
+using dd4hep::rec::volSurfaceList;
+using dd4hep::rec::ZPlanarData;
+using dd4hep::mm;
+
+/** Construction of the VXD detector, ported from Mokka driver SIT_Simple_Pixel.cc
+ *
+ *  Mokka History:
+ *  Feb 7th 2011, Steve Aplin - original version
+ *  F.Gaede, DESY, Jan 2014   - dd4hep SIT pixel
+ *  Hao Zeng, IHEP, July 2021
+ *  Chengdong FU, IHEP, Sep 2024 - composite from SiTrackerStaggeredLadder_v02 and SiTrackerStitching_v01
+ */
+
+static dd4hep::Ref_t create_element(dd4hep::Detector& theDetector, xml_h e, dd4hep::SensitiveDetector sens) {
+
+  xml_det_t  x_det    = e;
+  Material   air      = theDetector.air();
+  int        det_id   = x_det.id();
+  string     name     = x_det.nameStr();
+  DetElement det(name, det_id);
+
+  Volume envelope = dd4hep::xml::createPlacedEnvelope(theDetector, e, det);
+  dd4hep::xml::setDetectorTypeFlag(e, det) ;
+  if(theDetector.buildType()==dd4hep::BUILD_ENVELOPE) return det;
+  envelope.setVisAttributes(theDetector.visAttributes("SeeThrough"));
+
+  dd4hep::PrintLevel printLevel = dd4hep::ERROR;
+  if (x_det.hasAttr(_Unicode(printLevel))) {
+    printLevel = dd4hep::printLevel(x_det.attr<string>(_Unicode(printLevel)));
+  }
+  dd4hep::PrintLevel oldLevel = dd4hep::setPrintLevel(printLevel);
+
+  if (x_det.hasChild(_U(sensitive))) {
+    xml_dim_t sd_typ = x_det.child(_U(sensitive));
+    sens.setType(sd_typ.typeStr());
+  }
+  else {
+    sens.setType("tracker");
+  }
+
+  dd4hep::printout(dd4hep::INFO, "Construct", "** building SiTrackerComposite_v01 ...");
+
+  dd4hep::rec::CompositeData* compositeData = new dd4hep::rec::CompositeData;
+
+  //fetch the display parameters
+  xml_comp_t x_display(x_det.child(_Unicode(display)));
+  std::string ladderVis      = x_display.attr<string>(_Unicode(ladder));
+  std::string supportVis     = x_display.attr<string>(_Unicode(support));
+  std::string flexVis        = x_display.attr<string>(_Unicode(flex));
+  std::string sensEnvVis     = x_display.attr<string>(_Unicode(sens_env));
+  std::string sensVis        = x_display.attr<string>(_Unicode(sens));
+  std::string deadsensVis    = x_display.attr<string>(_Unicode(deadsensor));
+  std::string deadwireVis    = x_display.attr<string>(_Unicode(deadwire));
+
+  //fetch the shell parameters
+  if (x_det.hasChild(_Unicode(shell))) {
+    xml_comp_t x_shell(x_det.child(_Unicode(shell)));
+    double rmin_shell = x_shell.rmin();
+    double rmax_shell = x_shell.rmax();
+    double zhalf_shell = x_shell.zhalf();
+    Tube shellSolid(rmin_shell, rmax_shell, zhalf_shell);
+    Volume shellLogical(name + "_ShellLogical", shellSolid, theDetector.material(x_shell.materialStr()));
+    shellLogical.setVisAttributes(theDetector.visAttributes(x_shell.visStr()));
+    envelope.placeVolume(shellLogical);
+
+    compositeData->zHalfShell  = zhalf_shell;
+    compositeData->rInnerShell = rmin_shell;
+    compositeData->rOuterShell = rmax_shell;
+  }
+
+  for(xml_coll_t layer_i(x_det,_U(layer)); layer_i; ++layer_i){
+    xml_comp_t x_layer(layer_i);
+   
+    dd4hep::PlacedVolume pv;
+    int layer_id                 = x_layer.id();
+    bool isBent = false;
+    if (x_layer.hasAttr(_Unicode(isBent))) isBent = x_layer.attr<bool>(_Unicode(isBent));
+
+    dd4hep::printout(dd4hep::INFO, "Construct", "layer_id: %02d --- %s", layer_id, isBent ? "Stitching" : "Planar");
+
+    double z = x_layer.hasAttr(_U(z)) ? x_layer.z() : 0;
+
+    if (isBent) {
+      double phi0 = x_layer.phi0();
+
+      dd4hep::rec::CylindricalData::LayerLayout thisLayer;
+
+      int module_id = 0;
+      for (xml_coll_t module_i(x_layer, _U(module)); module_i; ++module_i) {
+	if (module_id>1) dd4hep::printout(dd4hep::ERROR, "Construct", "Not support more than two modules, possible wrong in reconstruction");
+
+	string name_module = name + dd4hep::_toString(layer_id, "_Layer%02d") + dd4hep::_toString(module_id, "_Stave%02d");
+	DetElement moduleDE(det, name_module, x_det.id());
+
+	xml_comp_t x_module(module_i);
+
+	double offset = x_module.offset();
+	double phi    = x_module.phi();
+
+	double radius = x_module.radius();
+	double xdead   = x_module.attr<double>(_Unicode(xdead));
+	double ydead   = x_module.attr<double>(_Unicode(ydead));
+	int nx = x_module.attr<int>(_Unicode(nx));
+	int ny = x_module.attr<int>(_Unicode(ny));
+	Material mat = theDetector.material(x_module.materialStr());
+
+	xml_comp_t x_sensor(x_module.child(_U(sensor)));
+	double sensor_thickness = x_sensor.thickness();
+	double sensor_width     = x_sensor.width();
+	double sensor_length    = x_sensor.length();
+	double sensor_dphi      = sensor_width/radius;
+	Material sensor_mat     = theDetector.material(x_sensor.materialStr());
+
+	Tube sensor_solid(radius, radius+sensor_thickness, sensor_length/2, -sensor_width/radius/2, sensor_width/radius/2);
+	Volume sensor_volume(name_module + "Sensor", sensor_solid, sensor_mat);
+	sensor_volume.setSensitiveDetector(sens);
+	if (x_det.hasAttr(_U(limits))) sensor_volume.setLimitSet(theDetector, x_det.limitsStr());
+	sensor_volume.setVisAttributes(theDetector.visAttributes(x_sensor.visStr()));
+
+	xml_comp_t x_flex(x_module.child(_Unicode(flex)));
+	std::vector<std::pair<double, Material> > flexs;
+	double flex_thickness = 0;
+	for (xml_coll_t slice_i(x_flex, _U(slice)); slice_i; ++slice_i) {
+	  xml_comp_t x_slice(slice_i);
+	  double thickness   = x_slice.thickness();
+	  Material mat_slice = theDetector.material(x_slice.materialStr());
+	  flexs.push_back(std::make_pair(thickness, mat_slice));
+	  flex_thickness += thickness;
+	  dd4hep::printout(dd4hep::DEBUG, "Construct", "flex %s: %f mm", mat_slice.name(), thickness/dd4hep::mm);
+	}
+	double flex_width  = sensor_width*ny + ydead*(ny-1);
+	double flex_length = sensor_length*nx + xdead*(nx-1);
+	double flex_radius = radius+sensor_thickness;
+	double flex_dphi   = flex_width/radius;
+	Tube flex_solid(flex_radius, flex_radius+flex_thickness, flex_length/2, -flex_dphi/2, flex_dphi/2);
+	Volume flex_volume(name_module + "Flex", flex_solid, air);
+	flex_volume.setVisAttributes(theDetector.visAttributes(x_flex.visStr()));
+	double start_radius = flex_radius;
+	for (unsigned islice=0; islice<flexs.size(); islice++) {
+	  dd4hep::printout(dd4hep::DEBUG, "Construct", "flex start radius: %f mm", start_radius/dd4hep::mm);
+	  Tube slice_solid(start_radius, start_radius+flexs[islice].first, flex_length/2, -flex_dphi/2, flex_dphi/2);
+	  Volume slice_volume(name_module + dd4hep::_toString(int(islice), "Flex_%d"), slice_solid, flexs[islice].second);
+	  flex_volume.placeVolume(slice_volume);
+	  start_radius += flexs[islice].first;
+	}
+
+	double service_radius = radius + sensor_thickness;
+
+	xml_comp_t x_electronics(x_module.child(_Unicode(electronics)));
+	double electronics_thickness = x_electronics.thickness();
+	double electronics_width = x_electronics.width();
+	double electronics_dphi  = electronics_width/radius;
+	Material electronics_mat = theDetector.material(x_electronics.materialStr());
+	Tube electronics_solid(service_radius, service_radius+electronics_thickness, flex_length/2, -electronics_dphi, 0);
+	Volume electronics_volume(name_module + "Electronics", electronics_solid, electronics_mat);
+	electronics_volume.setVisAttributes(theDetector.visAttributes(x_electronics.visStr()));
+
+	xml_comp_t x_readout(x_module.child(_U(readout)));
+	double readout_thickness = x_readout.thickness();
+	double readout_width = x_readout.width();
+	double readout_dphi  = readout_width/radius;
+	Material readout_mat = theDetector.material(x_readout.materialStr());
+	Tube readout_solid(service_radius, service_radius+readout_thickness, flex_length/2, 0, readout_dphi);
+	Volume readout_volume(name_module + "Electronics", readout_solid, readout_mat);
+	readout_volume.setVisAttributes(theDetector.visAttributes(x_readout.visStr()));
+
+	xml_comp_t x_driver(x_module.child(_Unicode(driver)));
+	double driver_thickness = x_driver.thickness();
+	// width -> length, length->width
+	double driver_length = x_driver.width();
+	double driver_width  = flex_width + electronics_width + readout_width;
+	double driver_dphi  = driver_width/radius;
+	Material driver_mat = theDetector.material(x_driver.materialStr());
+	Tube driver_solid(service_radius, service_radius+driver_thickness, driver_length/2, -flex_dphi/2-electronics_dphi, flex_dphi/2+readout_dphi);
+	Volume driver_volume(name_module + "Driver", driver_solid, driver_mat);
+	driver_volume.setVisAttributes(theDetector.visAttributes(x_driver.visStr()));
+
+	double module_length = flex_length + 2*driver_length;
+	double module_width  = driver_width;
+	double module_dphi   = module_width/radius;
+	double module_thickness = sensor_thickness + std::max(std::max(std::max(flex_thickness, driver_thickness), readout_thickness), electronics_thickness);
+	Tube module_solid(radius, radius+module_thickness, module_length/2, -flex_dphi/2-electronics_dphi, flex_dphi/2+readout_dphi);
+	Volume module_volume(name_module, module_solid, air);
+	module_volume.setVisAttributes(theDetector.visAttributes("SeeThrough"));
+
+	Tube board_solid(radius, radius+sensor_thickness, module_length/2, -flex_dphi/2-electronics_dphi, flex_dphi/2+readout_dphi);
+	Volume board_volume(name_module + "Board", board_solid, mat);
+	board_volume.setVisAttributes(theDetector.visAttributes(x_module.visStr()));
+	module_volume.placeVolume(board_volume);
+
+	for (int ix=0; ix<nx; ix++) {
+	  double z = -flex_length/2+sensor_length/2+ix*(sensor_length+xdead);
+	  for (int iy=0; iy<ny; iy++) {
+	    double delta = -flex_dphi/2+sensor_dphi/2+iy*(sensor_dphi+ydead/radius);
+	    Transform3D tran(RotationZ(delta), Position(0, 0, z));
+	    dd4hep::PlacedVolume pv = board_volume.placeVolume(sensor_volume, tran);
+
+	    int sensor_id = ix + nx*iy;
+	    pv.addPhysVolID("sensor", sensor_id);
+
+	    dd4hep::rec::Vector3D ocyl(radius + 0.5*sensor_thickness, 0., 0.);
+	    dd4hep::rec::VolCylinder surf(sensor_volume, dd4hep::rec::SurfaceType(dd4hep::rec::SurfaceType::Sensitive),
+					  0.5*sensor_thickness, module_thickness-0.5*sensor_thickness, ocyl);
+	    DetElement sensorDE(moduleDE, name_module + dd4hep::_toString(sensor_id, "_Sensor%02d"), x_det.id());
+	    sensorDE.setPlacement(pv);
+	    volSurfaceList(sensorDE)->push_back(surf);
+	  }
+	}
+
+	module_volume.placeVolume(flex_volume);
+	module_volume.placeVolume(electronics_volume, RotationZYX(-flex_dphi/2,0,0));
+	module_volume.placeVolume(readout_volume, RotationZYX(flex_dphi/2,0,0));
+	module_volume.placeVolume(driver_volume, Position(0, 0, -flex_length/2-driver_length/2));
+	module_volume.placeVolume(driver_volume, Position(0, 0,  flex_length/2+driver_length/2));
+
+	if (module_id == 0) {
+	  thisLayer.zHalf              = flex_length/2.0;
+	  thisLayer.radiusSensitive    = radius;
+	  thisLayer.thicknessSensitive = sensor_thickness;
+	  thisLayer.radiusSupport      = flex_radius;
+	  thisLayer.thicknessSupport   = flex_thickness;
+	  //thisLayer.width              = flex_width;
+	  thisLayer.phi0 = phi0 + phi;
+	  thisLayer.rgap = radius;
+	}
+	else {
+	  thisLayer.rgap = radius - thisLayer.rgap;
+          thisLayer.dphi = phi0 + phi - thisLayer.phi0;
+        }
+
+	Transform3D tran(RotationZ(phi0+phi), Position(offset*cos(phi), offset*sin(phi), z));
+	pv = envelope.placeVolume(module_volume, tran);
+	pv.addPhysVolID("layer", layer_id).addPhysVolID("module", module_id);
+
+	moduleDE.setPlacement(pv);
+
+	module_id++;
+      }
+
+      compositeData->layersBent.push_back(thisLayer);
+    }
+    else {
+      double sensitive_radius      = x_layer.attr<double>(_Unicode(ladder_radius));
+      int n_sensors_per_ladder     = x_layer.attr<int>(_Unicode(n_sensors_per_side));
+      int n_ladders                = x_layer.attr<int>(_Unicode(n_ladders)) ;
+      double ladder_offset         = x_layer.attr<double>(_Unicode(ladder_offset));
+      double ladder_radius         = sqrt(ladder_offset*ladder_offset + sensitive_radius*sensitive_radius); 
+      double ladder_phi0           = -atan(ladder_offset/sensitive_radius);
+      dd4hep::printout(dd4hep::INFO, "Construct", "ladder_radius = %f mm, sensitive_radius = %f mm, n_sensors_per_ladder = %d", ladder_radius/mm, sensitive_radius/mm, n_sensors_per_ladder);
+
+      std::string layerName = dd4hep::_toString(layer_id , "layer_%02d");
+      dd4hep::Assembly layer_assembly(layerName);
+      pv = envelope.placeVolume(layer_assembly);
+      dd4hep::DetElement layerDE(det, layerName, x_det.id());
+      layerDE.setPlacement(pv);
+    
+      const double ladder_dphi = ( dd4hep::twopi / n_ladders ) ;
+      dd4hep::printout(dd4hep::DEBUG, "Construct", "ladder_dphi: %f (%f degree)", ladder_dphi, ladder_dphi/dd4hep::degree);
+    
+      //fetch the ladder parameters
+      xml_comp_t x_ladder(x_layer.child(_Unicode(ladder)));
+    
+      //fetch the ladder support parameters
+      xml_comp_t x_ladder_support(x_ladder.child(_Unicode(ladderSupport)));
+      double support_length        = x_ladder_support.attr<double>(_Unicode(length));
+      double support_thickness     = x_ladder_support.attr<double>(_Unicode(thickness));
+      double support_height        = x_ladder_support.attr<double>(_Unicode(height));
+      double support_width         = x_ladder_support.attr<double>(_Unicode(width));
+      Material support_mat;
+      if(x_ladder_support.hasAttr(_Unicode(mat))) {
+	support_mat = theDetector.material(x_ladder_support.attr<string>(_Unicode(mat)));
+      }
+      else {
+	support_mat = theDetector.material(x_ladder_support.materialStr());
+      }
+      dd4hep::printout(dd4hep::INFO, "Construct", "support_length = %f mm, support_thickness = %f mm, support_width = %f mm", support_length/mm, support_thickness/mm, support_width/mm);
+
+      //fetch the flex parameters
+      double flex_thickness(0);
+      double flex_width(0);
+      double flex_length(0);
+      xml_comp_t x_flex(x_ladder.child(_Unicode(flex)));
+      for(xml_coll_t flex_i(x_flex,_U(slice)); flex_i; ++flex_i) {
+	xml_comp_t x_flex_slice(flex_i);
+	double x_flex_slice_thickness = x_flex_slice.attr<double>(_Unicode(thickness));
+	double x_flex_slice_width = x_flex_slice.attr<double>(_Unicode(width));
+	double x_flex_slice_length = x_flex_slice.attr<double>(_Unicode(length));
+	flex_thickness += x_flex_slice_thickness;
+	if (x_flex_slice_width > flex_width) flex_width = x_flex_slice_width;
+	if (x_flex_slice_length > flex_length) flex_length = x_flex_slice_length;
+	dd4hep::printout(dd4hep::DEBUG, "Construct", "x_flex_slice_thickness: %f mm", x_flex_slice_thickness/mm);
+      }
+      dd4hep::printout(dd4hep::INFO, "Construct", "flex_length = %f mm, flex_thickness = %f mm, flex_width = %f mm", flex_length/mm, flex_thickness/mm, flex_width/mm);
+
+      //fetch the sensor parameters
+      xml_comp_t x_sensor(x_ladder.child(_Unicode(sensor)));
+      int n_sensors_per_side                  = x_sensor.attr<int>(_Unicode(n_sensors));
+      double dead_gap                         = x_sensor.attr<double>(_Unicode(gap));
+      double sensor_thickness                 = x_sensor.attr<double>(_Unicode(thickness));
+      double sensor_active_len                = x_sensor.attr<double>(_Unicode(active_length));
+      double sensor_active_width              = x_sensor.attr<double>(_Unicode(active_width));
+      double sensor_dead_width                = x_sensor.attr<double>(_Unicode(dead_width));
+      double sensor_deadwire_length           = x_sensor.attr<double>(_Unicode(deadwire_length));
+      double sensor_deadwire_width            = x_sensor.attr<double>(_Unicode(deadwire_width));
+      double sensor_deadwire_thickness        = x_sensor.attr<double>(_Unicode(deadwire_thickness));
+      Material sensor_mat                     = theDetector.material(x_sensor.attr<string>(_Unicode(sensor_mat)));
+      Material sensor_deadwire_mat            = theDetector.material(x_sensor.attr<string>(_Unicode(deadwire_mat)));
+
+      dd4hep::printout(dd4hep::INFO, "Construct", "sensor_active_length = %f mm, sensor_thickness = %f mm, sensor_active_width = %f mm", sensor_active_len/mm, sensor_thickness/mm, sensor_active_width/mm);
+      dd4hep::printout(dd4hep::INFO, "Construct", "sensor_dead_width = %f mm, dead_gap = %f mm, n_sensors_per_side = %d", sensor_dead_width/mm, dead_gap/mm, n_sensors_per_side);
+
+      //create ladder logical volume
+      Box LadderSolid((support_height+2*sensor_thickness+2*flex_thickness)/2.0, support_width/2.0, support_length/2.0);
+      Volume LadderLogical(name + dd4hep::_toString(layer_id, "_LadderLogical_%02d"), LadderSolid, air);
+      // create flex envelope logical volume
+      Box FlexEnvelopeSolid(flex_thickness/2.0, flex_width/2.0, flex_length/2.0);
+      Volume FlexEnvelopeLogical(name + dd4hep::_toString( layer_id, "_FlexEnvelopeLogical_%02d"), FlexEnvelopeSolid, air);
+      FlexEnvelopeLogical.setVisAttributes(theDetector.visAttributes("SeeThrough"));
+
+      //create the flex layers inside the flex envelope
+      double flex_start_height(-flex_thickness/2.); 
+      int index = 0;
+      for(xml_coll_t flex_i(x_flex,_U(slice)); flex_i; ++flex_i){
+	xml_comp_t x_flex_slice(flex_i);
+	double x_flex_slice_thickness = x_flex_slice.attr<double>(_Unicode(thickness));
+	double x_flex_slice_width = x_flex_slice.attr<double>(_Unicode(width));
+	double x_flex_slice_length = x_flex_slice.attr<double>(_Unicode(length));
+	Material x_flex_slice_mat;
+	if(x_flex_slice.hasAttr(_Unicode(mat))) {
+	  x_flex_slice_mat = theDetector.material(x_flex_slice.attr<string>(_Unicode(mat)));
+	}
+	else {
+	  x_flex_slice_mat = theDetector.material(x_flex_slice.materialStr());
+	}
+	// Material x_flex_slice_mat = theDetector.material(x_flex_slice.attr<string>(_Unicode(mat)));
+	Box FlexLayerSolid(x_flex_slice_thickness/2.0, x_flex_slice_width/2.0, x_flex_slice_length/2.0);
+	Volume FlexLayerLogical(name + dd4hep::_toString( layer_id, "_FlexLayerLogical_%02d") + dd4hep::_toString( index, "index_%02d"), FlexLayerSolid, x_flex_slice_mat);
+	FlexLayerLogical.setVisAttributes(theDetector.visAttributes(flexVis));
+	double flex_slice_height = flex_start_height + x_flex_slice_thickness/2.;
+	pv = FlexEnvelopeLogical.placeVolume(FlexLayerLogical, Position(flex_slice_height, 0., 0.));
+	flex_start_height += x_flex_slice_thickness;
+	index++;
+      }
+
+      //place the flex envelope inside the ladder envelope
+      pv = LadderLogical.placeVolume(FlexEnvelopeLogical, Position((support_height + flex_thickness)/2.0, 0., 0.)); //top side
+      //define the transformation3D(only need a combination of translation and rotation)
+      Transform3D tran_mirro(RotationZYX(0., dd4hep::twopi/2.0, 0.), Position(-(support_height + flex_thickness)/2.0, 0., 0.));
+      pv = LadderLogical.placeVolume(FlexEnvelopeLogical, tran_mirro); //bottom side
+
+      //create sensor envelope logical volume
+      Box SensorTopEnvelopeSolid(sensor_thickness/2.0, support_width/2.0, support_length/2.0);
+      Volume SensorTopEnvelopeLogical(name + dd4hep::_toString( layer_id, "_SensorEnvelopeLogical_%02d"), SensorTopEnvelopeSolid, air);
+      Box SensorBottomEnvelopeSolid(sensor_thickness/2.0, support_width/2.0, support_length/2.0);
+      Volume SensorBottomEnvelopeLogical(name + dd4hep::_toString(layer_id, "_SensorEnvelopeLogical_%02d"), SensorBottomEnvelopeSolid, air);
+      SensorTopEnvelopeLogical.setVisAttributes(theDetector.visAttributes(sensEnvVis));
+
+      //create sensor logical volume
+      Box SensorSolid(sensor_thickness/2.0, sensor_active_width/2.0, sensor_active_len/2.0);
+      Volume SensorTopLogical(name + dd4hep::_toString(layer_id+1, "_SensorLogical_%02d"), SensorSolid, sensor_mat);
+      Volume SensorBottomLogical(name + dd4hep::_toString(layer_id, "_SensorLogical_%02d"), SensorSolid, sensor_mat);
+      SensorTopLogical.setSensitiveDetector(sens);
+      SensorBottomLogical.setSensitiveDetector(sens);
+      if (x_det.hasAttr(_U(limits))) {
+	SensorTopLogical.setLimitSet(theDetector, x_det.limitsStr());
+	SensorBottomLogical.setLimitSet(theDetector, x_det.limitsStr());
+      }
+      SensorTopLogical.setVisAttributes(theDetector.visAttributes(sensVis));
+      SensorBottomLogical.setVisAttributes(theDetector.visAttributes(sensVis));
+
+      //create dead sensor logical volume
+      Box SensorDeadSolid(sensor_thickness / 2.0, sensor_dead_width / 2.0, sensor_active_len / 2.0);
+      Volume SensorDeadLogical(name + dd4hep::_toString( layer_id, "_SensorDeadLogical_%02d"), SensorDeadSolid, sensor_mat);
+      SensorDeadLogical.setVisAttributes(theDetector.visAttributes(deadsensVis));
+
+      //create dead wire logical volume
+      Box SensorDeadWireSolid(sensor_deadwire_thickness / 2.0, sensor_deadwire_width / 2.0, sensor_deadwire_length / 2.0);
+      Volume SensorDeadWireLogical(name + dd4hep::_toString( layer_id, "_SensorDeadWireLogical_%02d"), SensorDeadWireSolid, sensor_deadwire_mat);
+      SensorDeadWireLogical.setVisAttributes(theDetector.visAttributes(deadwireVis));
+
+      //place the dead wire in the sensor envelope
+      // pv = SensorTopEnvelopeLogical.placeVolume(SensorDeadWireLogical, Position(0.0, (sensor_active_width-support_width/2.0) + sensor_dead_width/2.0 + sensor_deadwire_width/2.0, 0.0));
+      // pv = SensorBottomEnvelopeLogical.placeVolume(SensorDeadWireLogical, Position(0.0, (sensor_active_width-support_width/2.0) + sensor_dead_width/2.0 + sensor_deadwire_width/2.0, 0.0));
+      pv = SensorTopEnvelopeLogical.placeVolume(SensorDeadWireLogical, Position(0.0, (-support_width/2.0) + (sensor_deadwire_width/2.0), 0.0));
+      pv = SensorBottomEnvelopeLogical.placeVolume(SensorDeadWireLogical, Position(0.0, (-support_width/2.0) + (sensor_deadwire_width/2.0), 0.0));
+
+      // place the active sensor and dead sensor inside the sensor envelope
+      std::vector<dd4hep::PlacedVolume> TopSensor_pv;
+      std::vector<dd4hep::PlacedVolume> BottomSensor_pv;
+      for(int isensor=0; isensor < n_sensors_per_side; ++isensor){
+	double sensor_total_z = n_sensors_per_side*sensor_active_len + dead_gap*(n_sensors_per_side-1);
+	double xpos = 0.0;
+	double ypos_active = (support_width/2.0) - (sensor_active_width/2.0);
+	double ypos_dead = (-support_width/2.0) + sensor_deadwire_width + (sensor_dead_width/2.0);
+	double zpos = -sensor_total_z/2.0 + sensor_active_len/2.0 + isensor*(sensor_active_len + dead_gap);
+	pv = SensorTopEnvelopeLogical.placeVolume(SensorTopLogical, Position(xpos,ypos_active,zpos));
+	//pv.addPhysVolID("topsensor",  isensor ) ;
+	pv.addPhysVolID("layer", layer_id+1).addPhysVolID("sensor", isensor);
+	TopSensor_pv.push_back(pv);
+	pv = SensorBottomEnvelopeLogical.placeVolume(SensorBottomLogical, Position(xpos,ypos_active,zpos));
+	//pv.addPhysVolID("bottomsensor",  isensor ) ;
+	pv.addPhysVolID("layer", layer_id  ).addPhysVolID("sensor", isensor);
+	BottomSensor_pv.push_back(pv);
+	pv = SensorTopEnvelopeLogical.placeVolume(SensorDeadLogical, Position(xpos,ypos_dead,zpos));
+	pv = SensorBottomEnvelopeLogical.placeVolume(SensorDeadLogical, Position(xpos,ypos_dead,zpos));
+      }
+      //place the sensor envelope inside the ladder envelope
+      pv = LadderLogical.placeVolume(SensorTopEnvelopeLogical,
+				     Position(support_height/2.0 + flex_thickness + sensor_thickness/2.0, 0., 0.));//top-side sensors
+      Position pos(-(support_height/2.0 + flex_thickness + sensor_thickness/2.0), 0., 0.);
+      pv = LadderLogical.placeVolume(SensorBottomEnvelopeLogical, pos);//bottom-side sensors
+    
+      //create the ladder support
+      Box LadderSupportSolid(support_height/2.0, support_width/2.0, support_length/2.0);
+      Volume LadderSupportLogical(name + _toString( layer_id,"_SupLogical_%02d"), LadderSupportSolid, support_mat);
+      LadderSupportLogical.setVisAttributes(theDetector.visAttributes(supportVis));
+
+      //create ladder support cavity
+      Box LadderSupportCavitySolid(support_height/2.0-support_thickness/2.0, support_width/2.0-support_thickness/2.0, support_length/2.0);
+      Volume LadderSupportCavityLogical(name + _toString( layer_id,"_SupCavityLogical_%02d"), LadderSupportCavitySolid, air);
+      LadderSupportCavityLogical.setVisAttributes(theDetector.visAttributes("SeeThrough"));
+
+      pv = LadderSupportLogical.placeVolume(LadderSupportCavityLogical);
+      pv = LadderLogical.placeVolume(LadderSupportLogical);
+
+      for(int i = 0; i < n_ladders; i++){
+	std::stringstream ladder_enum; 
+	ladder_enum << "vxt_ladder_" << layer_id << "_" << i;
+	DetElement ladderDE(layerDE, ladder_enum.str(), x_det.id());
+	dd4hep::printout(dd4hep::DEBUG, "Construct", "start building %s", ladder_enum.str().c_str());
+
+	//====== create the meassurement surface ===================
+	dd4hep::rec::Vector3D o(0,0,0);
+	dd4hep::rec::Vector3D u( 0., 1., 0.);
+	dd4hep::rec::Vector3D v( 0., 0., 1.);
+	dd4hep::rec::Vector3D n( 1., 0., 0.);
+	// fucd: SensorLogical only sensor_thickness, support need another surface, todo
+	double inner_thick_top = sensor_thickness/2.0;
+	double outer_thick_top = sensor_thickness/2.0;//support_height/2.0 + flex_thickness + sensor_thickness/2.0;
+	double inner_thick_bottom = sensor_thickness/2.0;//support_height/2.0 + flex_thickness + sensor_thickness/2.0;
+	double outer_thick_bottom = sensor_thickness/2.0;
+	dd4hep::rec::VolPlane surfTop(SensorTopLogical,
+				      dd4hep::rec::SurfaceType(dd4hep::rec::SurfaceType::Sensitive),
+				      inner_thick_top, outer_thick_top, u, v, n, o);
+	dd4hep::rec::VolPlane surfBottom(SensorBottomLogical,
+					 dd4hep::rec::SurfaceType(dd4hep::rec::SurfaceType::Sensitive),
+					 inner_thick_bottom, outer_thick_bottom, u, v, n, o);
+
+	for(int isensor=0; isensor < n_sensors_per_side; ++isensor){
+	  std::stringstream topsensor_str;
+	  std::stringstream bottomsensor_str;
+	  topsensor_str << ladder_enum.str() << "_top_" << isensor;
+	  // std::cout << "\tstart building " << topsensor_str.str() << ":" << endl;
+	  bottomsensor_str << ladder_enum.str() << "_bottom_" << isensor;
+	  // std::cout << "\tstart building " << bottomsensor_str.str() << ":" << endl;
+	  DetElement topsensorDE(ladderDE, topsensor_str.str(), x_det.id());
+	  DetElement bottomsensorDE(ladderDE, bottomsensor_str.str(), x_det.id());
+	  topsensorDE.setPlacement(TopSensor_pv[isensor]);
+	  volSurfaceList(topsensorDE)->push_back(surfTop);
+	  // std::cout << "\t" << topsensor_str.str() << " done." << endl;
+	  bottomsensorDE.setPlacement(BottomSensor_pv[isensor]);
+	  // std::cout << "\t" << bottomsensor_str.str() << " done." << endl;
+	  volSurfaceList(bottomsensorDE)->push_back(surfBottom);
+	}
+	Transform3D tr (RotationZYX(ladder_dphi*i,0.,0.),Position(ladder_radius*cos(ladder_phi0+ladder_dphi*i), ladder_radius*sin(ladder_phi0+ladder_dphi*i), 0.));
+	pv = layer_assembly.placeVolume(LadderLogical,tr);
+	pv.addPhysVolID("module", i ) ; 
+	ladderDE.setPlacement(pv);
+	dd4hep::printout(dd4hep::DEBUG, "Construct", "%s done.", ladder_enum.str().c_str());
+	if(i==0) dd4hep::printout(dd4hep::DEBUG, "Construct", "(x,y) = (%f, %f)mm", ladder_radius*cos(ladder_phi0)/mm, ladder_radius*sin(ladder_phi0)/mm);
+      }
+
+      // package the reconstruction data
+      dd4hep::rec::ZPlanarData::LayerLayout topLayer;
+      dd4hep::rec::ZPlanarData::LayerLayout bottomLayer;
+
+      topLayer.ladderNumber         = n_ladders;
+      topLayer.phi0                 = 0.;
+      topLayer.sensorsPerLadder     = n_sensors_per_side;
+      topLayer.lengthSensor         = sensor_active_len;
+      topLayer.distanceSupport      = sensitive_radius;
+      topLayer.thicknessSupport     = support_thickness / 2.0;
+      topLayer.offsetSupport        = -ladder_offset;
+      topLayer.widthSupport         = support_width;
+      topLayer.zHalfSupport         = support_length / 2.0;
+      topLayer.distanceSensitive    = sensitive_radius + support_height / 2.0 + flex_thickness;
+      topLayer.thicknessSensitive   = sensor_thickness;
+      topLayer.offsetSensitive      = -ladder_offset + (support_width/2.0 - sensor_active_width/2.0);
+      topLayer.widthSensitive       = sensor_active_width;
+      topLayer.zHalfSensitive       = (n_sensors_per_side*(sensor_active_len + dead_gap) - dead_gap) / 2.0;
+
+      bottomLayer.ladderNumber         = n_ladders;
+      bottomLayer.phi0                 = 0.;
+      bottomLayer.sensorsPerLadder     = n_sensors_per_side;
+      bottomLayer.lengthSensor         = sensor_active_len;
+      bottomLayer.distanceSupport      = sensitive_radius - support_height / 2.0 - flex_thickness;
+      bottomLayer.thicknessSupport     = support_thickness / 2.0;
+      bottomLayer.offsetSupport        = -ladder_offset;
+      bottomLayer.widthSupport         = support_width;
+      bottomLayer.zHalfSupport         = support_length / 2.0;
+      bottomLayer.distanceSensitive    = sensitive_radius - support_height / 2.0 - sensor_thickness - flex_thickness;
+      bottomLayer.thicknessSensitive   = sensor_thickness;
+      bottomLayer.offsetSensitive      = -ladder_offset + (support_width/2.0 - sensor_active_width/2.0);
+      bottomLayer.widthSensitive       = sensor_active_width;
+      bottomLayer.zHalfSensitive       = (n_sensors_per_side*(sensor_active_len + dead_gap) - dead_gap) / 2.0;
+
+      compositeData->layersPlanar.push_back(bottomLayer);
+      compositeData->layersPlanar.push_back(topLayer);
+    }
+  }
+  if (dd4hep::printLevel()<=dd4hep::WARNING) std::cout << (*compositeData) << endl;
+  det.addExtension<dd4hep::rec::CompositeData>(compositeData);
+
+  if (x_det.hasAttr(_U(combineHits))) det.setCombineHits(x_det.attr<bool>(_U(combineHits)),sens);
+
+  dd4hep::printout(dd4hep::INFO, "Construct", "SiTrackerComposite_v01 done."); 
+  dd4hep::setPrintLevel(oldLevel);
+
+  return det;
+}
+DECLARE_DETELEMENT(SiTrackerComposite_v01,create_element)

Detector/DetCRD/src/Tracker/SiTrackerComposite_v02_geo.cpp

+//====================================================================
+//  cepcgeo - CEPC silicon detector models in DD4hep 
+//--------------------------------------------------------------------
+//  Chengdong FU and Tianyuan ZHANG, IHEP
+//  email: fucd@ihep.ac.cn
+//  $Id$
+//====================================================================
+#include "DD4hep/DetFactoryHelper.h"
+#include "DD4hep/DD4hepUnits.h"
+#include "DD4hep/DetType.h"
+#include "DD4hep/Printout.h"
+#include "DDRec/Surface.h"
+#include "DDRec/DetectorData.h"
+#include "XML/Utilities.h"
+#include <cmath>
+
+#include "DetIdentifier/CEPCDetectorData.h"
+
+using namespace std;
+
+using dd4hep::Box;
+using dd4hep::Tube;
+using dd4hep::DetElement;
+using dd4hep::Material;
+using dd4hep::Position;
+using dd4hep::RotationY;
+using dd4hep::RotationZ;
+using dd4hep::RotationZYX;
+using dd4hep::Transform3D;
+using dd4hep::Rotation3D;
+using dd4hep::Volume;
+using dd4hep::_toString;
+using dd4hep::rec::volSurfaceList;
+using dd4hep::rec::ZPlanarData;
+using dd4hep::mm;
+
+/** Construction of the VXD detector, ported from Mokka driver SIT_Simple_Pixel.cc
+ *
+ *  Mokka History:
+ *  Feb 7th 2011, Steve Aplin - original version
+ *  F.Gaede, DESY, Jan 2014   - dd4hep SIT pixel
+ *  Hao Zeng, IHEP, July 2021
+ *  Chengdong FU, IHEP, Sep 2024 - composite from SiTrackerStaggeredLadder_v02 and SiTrackerStitching_v01
+ *  Tianyuan ZHANG, IHEP, Dec 2024 - add sensor detail based on SiTrackerComposite_v01
+ */
+
+static dd4hep::Ref_t create_element(dd4hep::Detector& theDetector, xml_h e, dd4hep::SensitiveDetector sens) {
+
+  xml_det_t  x_det    = e;
+  Material   air      = theDetector.air();
+  int        det_id   = x_det.id();
+  string     name     = x_det.nameStr();
+  DetElement det(name, det_id);
+
+  Volume envelope = dd4hep::xml::createPlacedEnvelope(theDetector, e, det);
+  dd4hep::xml::setDetectorTypeFlag(e, det) ;
+  if(theDetector.buildType()==dd4hep::BUILD_ENVELOPE) return det;
+  envelope.setVisAttributes(theDetector.visAttributes("SeeThrough"));
+
+  dd4hep::PrintLevel printLevel = dd4hep::ERROR;
+  if (x_det.hasAttr(_Unicode(printLevel))) {
+    printLevel = dd4hep::printLevel(x_det.attr<string>(_Unicode(printLevel)));
+  }
+  dd4hep::PrintLevel oldLevel = dd4hep::setPrintLevel(printLevel);
+
+  if (x_det.hasChild(_U(sensitive))) {
+    xml_dim_t sd_typ = x_det.child(_U(sensitive));
+    sens.setType(sd_typ.typeStr());
+  }
+  else {
+    sens.setType("tracker");
+  }
+
+  dd4hep::printout(dd4hep::INFO, "Construct", "** building SiTrackerComposite_v02 ...");
+
+  dd4hep::rec::CompositeData* compositeData = new dd4hep::rec::CompositeData;
+
+  //fetch the display parameters
+  xml_comp_t x_display(x_det.child(_Unicode(display)));
+  std::string ladderVis      = x_display.attr<string>(_Unicode(ladder));
+  std::string supportVis     = x_display.attr<string>(_Unicode(support));
+  std::string flexVis        = x_display.attr<string>(_Unicode(flex));
+  std::string sensEnvVis     = x_display.attr<string>(_Unicode(sens_env));
+  std::string sensVis        = x_display.attr<string>(_Unicode(sens));
+  std::string deadsensVis    = x_display.attr<string>(_Unicode(deadsensor));
+  std::string deadwireVis    = x_display.attr<string>(_Unicode(deadwire));
+
+  //fetch the shell parameters
+  if (x_det.hasChild(_Unicode(shell))) {
+    xml_comp_t x_shell(x_det.child(_Unicode(shell)));
+    double rmin_shell = x_shell.rmin();
+    double rmax_shell = x_shell.rmax();
+    double zhalf_shell = x_shell.zhalf();
+    Tube shellSolid(rmin_shell, rmax_shell, zhalf_shell);
+    Volume shellLogical(name + "_ShellLogical", shellSolid, theDetector.material(x_shell.materialStr()));
+    shellLogical.setVisAttributes(theDetector.visAttributes(x_shell.visStr()));
+    envelope.placeVolume(shellLogical);
+
+    compositeData->zHalfShell  = zhalf_shell;
+    compositeData->rInnerShell = rmin_shell;
+    compositeData->rOuterShell = rmax_shell;
+  }
+
+  for(xml_coll_t layer_i(x_det,_U(layer)); layer_i; ++layer_i){
+    xml_comp_t x_layer(layer_i);
+   
+    dd4hep::PlacedVolume pv;
+    int layer_id                 = x_layer.id();
+    bool isBent = false;
+    if (x_layer.hasAttr(_Unicode(isBent))) isBent = x_layer.attr<bool>(_Unicode(isBent));
+
+    dd4hep::printout(dd4hep::INFO, "Construct", "layer_id: %02d --- %s", layer_id, isBent ? "Stitching" : "Planar");
+
+    double z = x_layer.hasAttr(_U(z)) ? x_layer.z() : 0;
+
+    if (isBent) {
+      double phi0 = x_layer.phi0();
+
+      dd4hep::rec::CylindricalData::LayerLayout thisLayer;
+
+      int module_id = 0;
+      for (xml_coll_t module_i(x_layer, _U(module)); module_i; ++module_i) {
+	if (module_id>1) dd4hep::printout(dd4hep::ERROR, "Construct", "Not support more than two modules, possible wrong in reconstruction");
+
+	string name_module = name + dd4hep::_toString(layer_id, "_Layer%02d") + dd4hep::_toString(module_id, "_Stave%02d");
+	DetElement moduleDE(det, name_module, x_det.id());
+
+	xml_comp_t x_module(module_i);
+
+	double offset = x_module.offset();
+	double phi    = x_module.phi();
+
+	double radius = x_module.radius();
+	double backbone = x_module.attr<double>(_Unicode(backbone));
+	double switches = x_module.attr<double>(_Unicode(switches));
+	double bias = x_module.attr<double>(_Unicode(bias));
+	double periphery = x_module.attr<double>(_Unicode(periphery));
+	double mechanical_gap = x_module.attr<double>(_Unicode(mechanical_gap));
+	int nx = x_module.attr<int>(_Unicode(nx));
+	int ny = x_module.attr<int>(_Unicode(ny));
+	Material mat = theDetector.material(x_module.materialStr());
+
+	xml_comp_t x_sensor(x_module.child(_U(sensor)));
+	double sensor_thickness = x_sensor.thickness();
+	double sensor_width     = x_sensor.width();
+	double sensor_length    = x_sensor.length();
+	double sensor_dphi      = sensor_width/radius;
+	Material sensor_mat     = theDetector.material(x_sensor.materialStr());
+
+	Tube sensor_solid(radius, radius+sensor_thickness, sensor_length/2, -sensor_width/radius/2, sensor_width/radius/2);
+	Volume sensor_volume(name_module + "Sensor", sensor_solid, sensor_mat);
+	sensor_volume.setSensitiveDetector(sens);
+	if (x_det.hasAttr(_U(limits))) sensor_volume.setLimitSet(theDetector, x_det.limitsStr());
+	sensor_volume.setVisAttributes(theDetector.visAttributes(x_sensor.visStr()));
+
+	xml_comp_t x_flex(x_module.child(_Unicode(flex)));
+	std::vector<std::pair<double, Material> > flexs;
+	double flex_thickness = 0;
+	for (xml_coll_t slice_i(x_flex, _U(slice)); slice_i; ++slice_i) {
+	  xml_comp_t x_slice(slice_i);
+	  double thickness   = x_slice.thickness();
+	  Material mat_slice = theDetector.material(x_slice.materialStr());
+	  flexs.push_back(std::make_pair(thickness, mat_slice));
+	  flex_thickness += thickness;
+	  dd4hep::printout(dd4hep::DEBUG, "Construct", "flex %s: %f mm", mat_slice.name(), thickness/dd4hep::mm);
+	}
+	double flex_width  = (sensor_width+periphery)*ny + bias*ny/2;
+	double flex_length = (sensor_length+switches)*nx + backbone*nx/3 + mechanical_gap;
+	double flex_radius = radius+sensor_thickness;
+	double flex_dphi   = flex_width/radius;
+	Tube flex_solid(flex_radius, flex_radius+flex_thickness, flex_length/2, -flex_dphi/2, flex_dphi/2);
+	Volume flex_volume(name_module + "Flex", flex_solid, air);
+	flex_volume.setVisAttributes(theDetector.visAttributes(x_flex.visStr()));
+	double start_radius = flex_radius;
+	for (unsigned islice=0; islice<flexs.size(); islice++) {
+	  dd4hep::printout(dd4hep::DEBUG, "Construct", "flex start radius: %f mm", start_radius/dd4hep::mm);
+	  Tube slice_solid(start_radius, start_radius+flexs[islice].first, flex_length/2, -flex_dphi/2, flex_dphi/2);
+	  Volume slice_volume(name_module + dd4hep::_toString(int(islice), "Flex_%d"), slice_solid, flexs[islice].second);
+	  flex_volume.placeVolume(slice_volume);
+	  start_radius += flexs[islice].first;
+	}
+
+	double service_radius = radius + sensor_thickness;
+
+	// in fact driver, the left impact as name of readout
+	xml_comp_t x_readout(x_module.child(_Unicode(readout)));
+	double readout_thickness = x_readout.thickness();
+	double readout_length = x_readout.width();
+	double readout_width  = flex_width;
+	double readout_dphi  = readout_width/radius;
+	Material readout_mat = theDetector.material(x_readout.materialStr());
+	Tube readout_solid(service_radius, service_radius+readout_thickness, readout_length/2, -flex_dphi/2, flex_dphi/2);
+	Volume readout_volume(name_module + "DriverL", readout_solid, readout_mat);
+	readout_volume.setVisAttributes(theDetector.visAttributes(x_readout.visStr()));
+
+	xml_comp_t x_driver(x_module.child(_Unicode(driver)));
+        double driver_thickness = x_driver.thickness();
+        double driver_length = x_driver.width();
+        double driver_width  = flex_width;
+        double driver_dphi  = driver_width/radius;
+        Material driver_mat = theDetector.material(x_driver.materialStr());
+        Tube driver_solid(service_radius, service_radius+driver_thickness, driver_length/2, -flex_dphi/2, flex_dphi/2);
+        Volume driver_volume(name_module + "DriverR", driver_solid, driver_mat);
+        driver_volume.setVisAttributes(theDetector.visAttributes(x_driver.visStr()));
+
+	double module_length = flex_length + readout_length + driver_length;
+	double module_width  = flex_width;
+	double module_dphi   = module_width/radius;
+	double module_thickness = sensor_thickness + std::max(flex_thickness, std::max(readout_thickness,driver_thickness));
+	Tube module_solid(radius, radius+module_thickness, module_length/2, -flex_dphi/2, flex_dphi/2);
+	Volume module_volume(name_module, module_solid, air);
+	module_volume.setVisAttributes(theDetector.visAttributes("SeeThrough"));
+
+	Tube board_solid(radius, radius+sensor_thickness, module_length/2, -flex_dphi/2, flex_dphi/2);
+	Volume board_volume(name_module + "Board", board_solid, mat);
+	board_volume.setVisAttributes(theDetector.visAttributes(x_module.visStr()));
+	module_volume.placeVolume(board_volume);
+
+	double z_bent = 0.0;
+	double delta = 0.0;
+	for (int ix = 0; ix < nx; ix++) {
+	    if (ix < nx / 2) {
+		z_bent = -flex_length/2 + sensor_length/2 + (static_cast<int>(ix/3) + 1)*backbone + ix*(sensor_length + switches);
+	    }
+	    else {
+		z_bent = -flex_length/2 + sensor_length/2 + (static_cast<int>(ix/3) + 1)*backbone + ix*(sensor_length + switches) + mechanical_gap;
+	    }
+	    for (int iy = 0; iy < ny; iy++) {
+	        if (iy % 2 != 0) {
+		    delta = -flex_dphi/2 + sensor_dphi/2 + iy*(sensor_dphi + periphery/radius) + ((iy + 1)/2)*bias/radius;
+	        }
+	        else {
+		    delta = -flex_dphi/2 + sensor_dphi/2 + iy*sensor_dphi + (iy + 1)*periphery / radius + iy/2*bias/radius;
+	        }
+		Transform3D tran(RotationZ(delta), Position(0, 0, z_bent));
+		dd4hep::PlacedVolume pv = board_volume.placeVolume(sensor_volume, tran);
+
+		int sensor_id = ix + nx*iy;
+		pv.addPhysVolID("sensor", sensor_id);
+		dd4hep::rec::Vector3D ocyl(radius + 0.5 * sensor_thickness, 0., 0.);
+		dd4hep::rec::VolCylinder surf(sensor_volume, dd4hep::rec::SurfaceType(dd4hep::rec::SurfaceType::Sensitive),
+		0.5 * sensor_thickness, module_thickness - 0.5 * sensor_thickness, ocyl);
+		DetElement sensorDE(moduleDE, name_module + dd4hep::_toString(sensor_id, "_Sensor%02d"), x_det.id());
+		sensorDE.setPlacement(pv);
+		volSurfaceList(sensorDE)->push_back(surf);
+	  }
+        }
+
+	module_volume.placeVolume(flex_volume, Position(0, 0, readout_length/2-driver_length/2));
+	module_volume.placeVolume(readout_volume, Position(0, 0, -flex_length/2-driver_length/2));
+	module_volume.placeVolume(driver_volume, Position(0, 0,  flex_length/2+readout_length/2));
+
+	if (module_id == 0) {
+	  thisLayer.zHalf              = flex_length/2.0;
+	  thisLayer.radiusSensitive    = radius;
+	  thisLayer.thicknessSensitive = sensor_thickness;
+	  thisLayer.radiusSupport      = flex_radius;
+	  thisLayer.thicknessSupport   = flex_thickness;
+	  thisLayer.width              = flex_width;
+	  thisLayer.phi0 = phi0 + phi;
+	  thisLayer.rgap = radius;
+	}
+	else {
+	  thisLayer.rgap = radius - thisLayer.rgap;
+          thisLayer.dphi = phi0 + phi - thisLayer.phi0;
+        }
+
+	Transform3D tran(RotationZ(phi0+phi), Position(offset*cos(phi), offset*sin(phi), z));
+	pv = envelope.placeVolume(module_volume, tran);
+	pv.addPhysVolID("layer", layer_id).addPhysVolID("module", module_id);
+
+	moduleDE.setPlacement(pv);
+
+	module_id++;
+      }
+
+      compositeData->layersBent.push_back(thisLayer);
+    }
+    else {
+      double sensitive_radius      = x_layer.attr<double>(_Unicode(ladder_radius));
+      int n_sensors_per_ladder     = x_layer.attr<int>(_Unicode(n_sensors_per_side));
+      int n_ladders                = x_layer.attr<int>(_Unicode(n_ladders)) ;
+      double ladder_offset         = x_layer.attr<double>(_Unicode(ladder_offset));
+      double ladder_radius         = sqrt(ladder_offset*ladder_offset + sensitive_radius*sensitive_radius); 
+      double ladder_phi0           = -atan(ladder_offset/sensitive_radius);
+      dd4hep::printout(dd4hep::INFO, "Construct", "ladder_radius = %f mm, sensitive_radius = %f mm, n_sensors_per_ladder = %d", ladder_radius/mm, sensitive_radius/mm, n_sensors_per_ladder);
+
+      std::string layerName = dd4hep::_toString(layer_id , "layer_%02d");
+      dd4hep::Assembly layer_assembly(layerName);
+      pv = envelope.placeVolume(layer_assembly);
+      dd4hep::DetElement layerDE(det, layerName, x_det.id());
+      layerDE.setPlacement(pv);
+    
+      const double ladder_dphi = ( dd4hep::twopi / n_ladders ) ;
+      dd4hep::printout(dd4hep::DEBUG, "Construct", "ladder_dphi: %f (%f degree)", ladder_dphi, ladder_dphi/dd4hep::degree);
+    
+      //fetch the ladder parameters
+      xml_comp_t x_ladder(x_layer.child(_Unicode(ladder)));
+    
+      //fetch the ladder support parameters
+      xml_comp_t x_ladder_support(x_ladder.child(_Unicode(ladderSupport)));
+      double support_length        = x_ladder_support.attr<double>(_Unicode(length));
+      double support_thickness     = x_ladder_support.attr<double>(_Unicode(thickness));
+      double support_height        = x_ladder_support.attr<double>(_Unicode(height));
+      double support_width         = x_ladder_support.attr<double>(_Unicode(width));
+      Material support_mat;
+      if(x_ladder_support.hasAttr(_Unicode(mat))) {
+	support_mat = theDetector.material(x_ladder_support.attr<string>(_Unicode(mat)));
+      }
+      else {
+	support_mat = theDetector.material(x_ladder_support.materialStr());
+      }
+      dd4hep::printout(dd4hep::INFO, "Construct", "support_length = %f mm, support_thickness = %f mm, support_width = %f mm", support_length/mm, support_thickness/mm, support_width/mm);
+
+      //fetch the flex parameters
+      double flex_thickness(0);
+      double flex_width(0);
+      double flex_length(0);
+      xml_comp_t x_flex(x_ladder.child(_Unicode(flex)));
+      for(xml_coll_t flex_i(x_flex,_U(slice)); flex_i; ++flex_i) {
+	xml_comp_t x_flex_slice(flex_i);
+	double x_flex_slice_thickness = x_flex_slice.attr<double>(_Unicode(thickness));
+	double x_flex_slice_width = x_flex_slice.attr<double>(_Unicode(width));
+	double x_flex_slice_length = x_flex_slice.attr<double>(_Unicode(length));
+	flex_thickness += x_flex_slice_thickness;
+	if (x_flex_slice_width > flex_width) flex_width = x_flex_slice_width;
+	if (x_flex_slice_length > flex_length) flex_length = x_flex_slice_length;
+	dd4hep::printout(dd4hep::DEBUG, "Construct", "x_flex_slice_thickness: %f mm", x_flex_slice_thickness/mm);
+      }
+      dd4hep::printout(dd4hep::INFO, "Construct", "flex_length = %f mm, flex_thickness = %f mm, flex_width = %f mm", flex_length/mm, flex_thickness/mm, flex_width/mm);
+
+      //fetch the sensor parameters
+      xml_comp_t x_sensor(x_ladder.child(_Unicode(sensor)));
+      int n_sensors_per_side                  = x_sensor.attr<int>(_Unicode(n_sensors));
+      double dead_gap                         = x_sensor.attr<double>(_Unicode(gap));
+      double sensor_thickness                 = x_sensor.attr<double>(_Unicode(thickness));
+      double sensor_active_len                = x_sensor.attr<double>(_Unicode(active_length));
+      double sensor_active_width              = x_sensor.attr<double>(_Unicode(active_width));
+      double sensor_dead_width                = x_sensor.attr<double>(_Unicode(dead_width));
+      double sensor_deadwire_length           = x_sensor.attr<double>(_Unicode(deadwire_length));
+      double sensor_deadwire_width            = x_sensor.attr<double>(_Unicode(deadwire_width));
+      double sensor_deadwire_thickness        = x_sensor.attr<double>(_Unicode(deadwire_thickness));
+      Material sensor_mat                     = theDetector.material(x_sensor.attr<string>(_Unicode(sensor_mat)));
+      Material sensor_deadwire_mat            = theDetector.material(x_sensor.attr<string>(_Unicode(deadwire_mat)));
+
+      dd4hep::printout(dd4hep::INFO, "Construct", "sensor_active_length = %f mm, sensor_thickness = %f mm, sensor_active_width = %f mm", sensor_active_len/mm, sensor_thickness/mm, sensor_active_width/mm);
+      dd4hep::printout(dd4hep::INFO, "Construct", "sensor_dead_width = %f mm, dead_gap = %f mm, n_sensors_per_side = %d", sensor_dead_width/mm, dead_gap/mm, n_sensors_per_side);
+
+      //create ladder logical volume
+      Box LadderSolid((support_height+2*sensor_thickness+2*flex_thickness)/2.0, support_width/2.0, support_length/2.0);
+      Volume LadderLogical(name + dd4hep::_toString(layer_id, "_LadderLogical_%02d"), LadderSolid, air);
+      // create flex envelope logical volume
+      Box FlexEnvelopeSolid(flex_thickness/2.0, flex_width/2.0, flex_length/2.0);
+      Volume FlexEnvelopeLogical(name + dd4hep::_toString( layer_id, "_FlexEnvelopeLogical_%02d"), FlexEnvelopeSolid, air);
+      FlexEnvelopeLogical.setVisAttributes(theDetector.visAttributes("SeeThrough"));
+
+      //create the flex layers inside the flex envelope
+      double flex_start_height(-flex_thickness/2.); 
+      int index = 0;
+      for(xml_coll_t flex_i(x_flex,_U(slice)); flex_i; ++flex_i){
+	xml_comp_t x_flex_slice(flex_i);
+	double x_flex_slice_thickness = x_flex_slice.attr<double>(_Unicode(thickness));
+	double x_flex_slice_width = x_flex_slice.attr<double>(_Unicode(width));
+	double x_flex_slice_length = x_flex_slice.attr<double>(_Unicode(length));
+	Material x_flex_slice_mat;
+	if(x_flex_slice.hasAttr(_Unicode(mat))) {
+	  x_flex_slice_mat = theDetector.material(x_flex_slice.attr<string>(_Unicode(mat)));
+	}
+	else {
+	  x_flex_slice_mat = theDetector.material(x_flex_slice.materialStr());
+	}
+	// Material x_flex_slice_mat = theDetector.material(x_flex_slice.attr<string>(_Unicode(mat)));
+	Box FlexLayerSolid(x_flex_slice_thickness/2.0, x_flex_slice_width/2.0, x_flex_slice_length/2.0);
+	Volume FlexLayerLogical(name + dd4hep::_toString( layer_id, "_FlexLayerLogical_%02d") + dd4hep::_toString( index, "index_%02d"), FlexLayerSolid, x_flex_slice_mat);
+	FlexLayerLogical.setVisAttributes(theDetector.visAttributes(flexVis));
+	double flex_slice_height = flex_start_height + x_flex_slice_thickness/2.;
+	pv = FlexEnvelopeLogical.placeVolume(FlexLayerLogical, Position(flex_slice_height, 0., 0.));
+	flex_start_height += x_flex_slice_thickness;
+	index++;
+      }
+
+      //place the flex envelope inside the ladder envelope
+      pv = LadderLogical.placeVolume(FlexEnvelopeLogical, Position((support_height + flex_thickness)/2.0, 0., 0.)); //top side
+      //define the transformation3D(only need a combination of translation and rotation)
+      Transform3D tran_mirro(RotationZYX(0., dd4hep::twopi/2.0, 0.), Position(-(support_height + flex_thickness)/2.0, 0., 0.));
+      pv = LadderLogical.placeVolume(FlexEnvelopeLogical, tran_mirro); //bottom side
+
+      //create sensor envelope logical volume
+      Box SensorTopEnvelopeSolid(sensor_thickness/2.0, support_width/2.0, support_length/2.0);
+      Volume SensorTopEnvelopeLogical(name + dd4hep::_toString( layer_id, "_SensorEnvelopeLogical_%02d"), SensorTopEnvelopeSolid, air);
+      Box SensorBottomEnvelopeSolid(sensor_thickness/2.0, support_width/2.0, support_length/2.0);
+      Volume SensorBottomEnvelopeLogical(name + dd4hep::_toString(layer_id, "_SensorEnvelopeLogical_%02d"), SensorBottomEnvelopeSolid, air);
+      SensorTopEnvelopeLogical.setVisAttributes(theDetector.visAttributes(sensEnvVis));
+
+      //create sensor logical volume
+      Box SensorSolid(sensor_thickness/2.0, sensor_active_width/2.0, sensor_active_len/2.0);
+      Volume SensorTopLogical(name + dd4hep::_toString(layer_id+1, "_SensorLogical_%02d"), SensorSolid, sensor_mat);
+      Volume SensorBottomLogical(name + dd4hep::_toString(layer_id, "_SensorLogical_%02d"), SensorSolid, sensor_mat);
+      SensorTopLogical.setSensitiveDetector(sens);
+      SensorBottomLogical.setSensitiveDetector(sens);
+      if (x_det.hasAttr(_U(limits))) {
+	SensorTopLogical.setLimitSet(theDetector, x_det.limitsStr());
+	SensorBottomLogical.setLimitSet(theDetector, x_det.limitsStr());
+      }
+      SensorTopLogical.setVisAttributes(theDetector.visAttributes(sensVis));
+      SensorBottomLogical.setVisAttributes(theDetector.visAttributes(sensVis));
+
+      //create dead sensor logical volume
+      Box SensorDeadSolid(sensor_thickness / 2.0, sensor_dead_width / 2.0, sensor_active_len / 2.0);
+      Volume SensorDeadLogical(name + dd4hep::_toString( layer_id, "_SensorDeadLogical_%02d"), SensorDeadSolid, sensor_mat);
+      SensorDeadLogical.setVisAttributes(theDetector.visAttributes(deadsensVis));
+
+      //create dead wire logical volume
+      Box SensorDeadWireSolid(sensor_deadwire_thickness / 2.0, sensor_deadwire_width / 2.0, sensor_deadwire_length / 2.0);
+      Volume SensorDeadWireLogical(name + dd4hep::_toString( layer_id, "_SensorDeadWireLogical_%02d"), SensorDeadWireSolid, sensor_deadwire_mat);
+      SensorDeadWireLogical.setVisAttributes(theDetector.visAttributes(deadwireVis));
+
+      //place the dead wire in the sensor envelope
+      // pv = SensorTopEnvelopeLogical.placeVolume(SensorDeadWireLogical, Position(0.0, (sensor_active_width-support_width/2.0) + sensor_dead_width/2.0 + sensor_deadwire_width/2.0, 0.0));
+      // pv = SensorBottomEnvelopeLogical.placeVolume(SensorDeadWireLogical, Position(0.0, (sensor_active_width-support_width/2.0) + sensor_dead_width/2.0 + sensor_deadwire_width/2.0, 0.0));
+      pv = SensorTopEnvelopeLogical.placeVolume(SensorDeadWireLogical, Position(0.0, (-support_width/2.0) + (sensor_deadwire_width/2.0), 0.0));
+      pv = SensorBottomEnvelopeLogical.placeVolume(SensorDeadWireLogical, Position(0.0, (-support_width/2.0) + (sensor_deadwire_width/2.0), 0.0));
+
+      // place the active sensor and dead sensor inside the sensor envelope
+      std::vector<dd4hep::PlacedVolume> TopSensor_pv;
+      std::vector<dd4hep::PlacedVolume> BottomSensor_pv;
+      for(int isensor=0; isensor < n_sensors_per_side; ++isensor){
+	double sensor_total_z = n_sensors_per_side*sensor_active_len + dead_gap*(n_sensors_per_side-1);
+	double xpos = 0.0;
+	double ypos_active = (support_width/2.0) - (sensor_active_width/2.0);
+	double ypos_dead = (-support_width/2.0) + sensor_deadwire_width + (sensor_dead_width/2.0);
+	double zpos = -sensor_total_z/2.0 + sensor_active_len/2.0 + isensor*(sensor_active_len + dead_gap);
+	pv = SensorTopEnvelopeLogical.placeVolume(SensorTopLogical, Position(xpos,ypos_active,zpos));
+	//pv.addPhysVolID("topsensor",  isensor ) ;
+	pv.addPhysVolID("layer", layer_id+1).addPhysVolID("sensor", isensor);
+	TopSensor_pv.push_back(pv);
+	pv = SensorBottomEnvelopeLogical.placeVolume(SensorBottomLogical, Position(xpos,ypos_active,zpos));
+	//pv.addPhysVolID("bottomsensor",  isensor ) ;
+	pv.addPhysVolID("layer", layer_id  ).addPhysVolID("sensor", isensor);
+	BottomSensor_pv.push_back(pv);
+	pv = SensorTopEnvelopeLogical.placeVolume(SensorDeadLogical, Position(xpos,ypos_dead,zpos));
+	pv = SensorBottomEnvelopeLogical.placeVolume(SensorDeadLogical, Position(xpos,ypos_dead,zpos));
+      }
+      //place the sensor envelope inside the ladder envelope
+      pv = LadderLogical.placeVolume(SensorTopEnvelopeLogical,
+				     Position(support_height/2.0 + flex_thickness + sensor_thickness/2.0, 0., 0.));//top-side sensors
+      Position pos(-(support_height/2.0 + flex_thickness + sensor_thickness/2.0), 0., 0.);
+      pv = LadderLogical.placeVolume(SensorBottomEnvelopeLogical, pos);//bottom-side sensors
+    
+      //create the ladder support
+      Box LadderSupportSolid(support_height/2.0, support_width/2.0, support_length/2.0);
+      Volume LadderSupportLogical(name + _toString( layer_id,"_SupLogical_%02d"), LadderSupportSolid, support_mat);
+      LadderSupportLogical.setVisAttributes(theDetector.visAttributes(supportVis));
+
+      //create ladder support cavity
+      Box LadderSupportCavitySolid(support_height/2.0-support_thickness/2.0, support_width/2.0-support_thickness/2.0, support_length/2.0);
+      Volume LadderSupportCavityLogical(name + _toString( layer_id,"_SupCavityLogical_%02d"), LadderSupportCavitySolid, air);
+      LadderSupportCavityLogical.setVisAttributes(theDetector.visAttributes("SeeThrough"));
+
+      pv = LadderSupportLogical.placeVolume(LadderSupportCavityLogical);
+      pv = LadderLogical.placeVolume(LadderSupportLogical);
+
+      for(int i = 0; i < n_ladders; i++){
+	std::stringstream ladder_enum; 
+	ladder_enum << "vxt_ladder_" << layer_id << "_" << i;
+	DetElement ladderDE(layerDE, ladder_enum.str(), x_det.id());
+	dd4hep::printout(dd4hep::DEBUG, "Construct", "start building %s", ladder_enum.str().c_str());
+
+	//====== create the meassurement surface ===================
+	dd4hep::rec::Vector3D o(0,0,0);
+	dd4hep::rec::Vector3D u( 0., 1., 0.);
+	dd4hep::rec::Vector3D v( 0., 0., 1.);
+	dd4hep::rec::Vector3D n( 1., 0., 0.);
+	// fucd: SensorLogical only sensor_thickness, support need another surface, todo
+	double inner_thick_top = sensor_thickness/2.0;
+	double outer_thick_top = sensor_thickness/2.0;//support_height/2.0 + flex_thickness + sensor_thickness/2.0;
+	double inner_thick_bottom = sensor_thickness/2.0;//support_height/2.0 + flex_thickness + sensor_thickness/2.0;
+	double outer_thick_bottom = sensor_thickness/2.0;
+	dd4hep::rec::VolPlane surfTop(SensorTopLogical,
+				      dd4hep::rec::SurfaceType(dd4hep::rec::SurfaceType::Sensitive),
+				      inner_thick_top, outer_thick_top, u, v, n, o);
+	dd4hep::rec::VolPlane surfBottom(SensorBottomLogical,
+					 dd4hep::rec::SurfaceType(dd4hep::rec::SurfaceType::Sensitive),
+					 inner_thick_bottom, outer_thick_bottom, u, v, n, o);
+
+	for(int isensor=0; isensor < n_sensors_per_side; ++isensor){
+	  std::stringstream topsensor_str;
+	  std::stringstream bottomsensor_str;
+	  topsensor_str << ladder_enum.str() << "_top_" << isensor;
+	  // std::cout << "\tstart building " << topsensor_str.str() << ":" << endl;
+	  bottomsensor_str << ladder_enum.str() << "_bottom_" << isensor;
+	  // std::cout << "\tstart building " << bottomsensor_str.str() << ":" << endl;
+	  DetElement topsensorDE(ladderDE, topsensor_str.str(), x_det.id());
+	  DetElement bottomsensorDE(ladderDE, bottomsensor_str.str(), x_det.id());
+	  topsensorDE.setPlacement(TopSensor_pv[isensor]);
+	  volSurfaceList(topsensorDE)->push_back(surfTop);
+	  // std::cout << "\t" << topsensor_str.str() << " done." << endl;
+	  bottomsensorDE.setPlacement(BottomSensor_pv[isensor]);
+	  // std::cout << "\t" << bottomsensor_str.str() << " done." << endl;
+	  volSurfaceList(bottomsensorDE)->push_back(surfBottom);
+	}
+	Transform3D tr (RotationZYX(ladder_dphi*i,0.,0.),Position(ladder_radius*cos(ladder_phi0+ladder_dphi*i), ladder_radius*sin(ladder_phi0+ladder_dphi*i), 0.));
+	pv = layer_assembly.placeVolume(LadderLogical,tr);
+	pv.addPhysVolID("module", i ) ; 
+	ladderDE.setPlacement(pv);
+	dd4hep::printout(dd4hep::DEBUG, "Construct", "%s done.", ladder_enum.str().c_str());
+	if(i==0) dd4hep::printout(dd4hep::DEBUG, "Construct", "(x,y) = (%f, %f)mm", ladder_radius*cos(ladder_phi0)/mm, ladder_radius*sin(ladder_phi0)/mm);
+      }
+
+      // package the reconstruction data
+      dd4hep::rec::ZPlanarData::LayerLayout topLayer;
+      dd4hep::rec::ZPlanarData::LayerLayout bottomLayer;
+
+      topLayer.ladderNumber         = n_ladders;
+      topLayer.phi0                 = 0.;
+      topLayer.sensorsPerLadder     = n_sensors_per_side;
+      topLayer.lengthSensor         = sensor_active_len;
+      topLayer.distanceSupport      = sensitive_radius + support_height / 2.0 - support_thickness / 2.0;
+      topLayer.thicknessSupport     = support_thickness / 2.0 + flex_thickness;
+      topLayer.offsetSupport        = -ladder_offset;
+      topLayer.widthSupport         = support_width;
+      topLayer.zHalfSupport         = support_length / 2.0;
+      topLayer.distanceSensitive    = sensitive_radius + support_height / 2.0 + flex_thickness;
+      topLayer.thicknessSensitive   = sensor_thickness;
+      topLayer.offsetSensitive      = -ladder_offset + (support_width/2.0 - sensor_active_width/2.0);
+      topLayer.widthSensitive       = sensor_active_width;
+      topLayer.zHalfSensitive       = (n_sensors_per_side*(sensor_active_len + dead_gap) - dead_gap) / 2.0;
+
+      bottomLayer.ladderNumber         = n_ladders;
+      bottomLayer.phi0                 = 0.;
+      bottomLayer.sensorsPerLadder     = n_sensors_per_side;
+      bottomLayer.lengthSensor         = sensor_active_len;
+      bottomLayer.distanceSupport      = sensitive_radius - support_height / 2.0 - flex_thickness;
+      bottomLayer.thicknessSupport     = support_thickness / 2.0 + flex_thickness;
+      bottomLayer.offsetSupport        = -ladder_offset;
+      bottomLayer.widthSupport         = support_width;
+      bottomLayer.zHalfSupport         = support_length / 2.0;
+      bottomLayer.distanceSensitive    = sensitive_radius - support_height / 2.0 - sensor_thickness - flex_thickness;
+      bottomLayer.thicknessSensitive   = sensor_thickness;
+      bottomLayer.offsetSensitive      = -ladder_offset + (support_width/2.0 - sensor_active_width/2.0);
+      bottomLayer.widthSensitive       = sensor_active_width;
+      bottomLayer.zHalfSensitive       = (n_sensors_per_side*(sensor_active_len + dead_gap) - dead_gap) / 2.0;
+
+      compositeData->layersPlanar.push_back(bottomLayer);
+      compositeData->layersPlanar.push_back(topLayer);
+    }
+  }
+  if (dd4hep::printLevel()<=dd4hep::WARNING) std::cout << (*compositeData) << endl;
+  det.addExtension<dd4hep::rec::CompositeData>(compositeData);
+
+  if (x_det.hasAttr(_U(combineHits))) det.setCombineHits(x_det.attr<bool>(_U(combineHits)),sens);
+
+  dd4hep::printout(dd4hep::INFO, "Construct", "SiTrackerComposite_v02 done."); 
+  dd4hep::setPrintLevel(oldLevel);
+
+  return det;
+}
+DECLARE_DETELEMENT(SiTrackerComposite_v02,create_element)

Detector/DetCRD/src/Tracker/SiTrackerComposite_v03_geo.cpp

+//====================================================================
+//  cepcgeo - CEPC silicon detector models in DD4hep 
+//--------------------------------------------------------------------
+//  Chengdong FU and Tianyuan ZHANG, IHEP
+//  email: fucd@ihep.ac.cn
+//  $Id$
+//====================================================================
+#include "DD4hep/DetFactoryHelper.h"
+#include "DD4hep/DD4hepUnits.h"
+#include "DD4hep/DetType.h"
+#include "DD4hep/Printout.h"
+#include "DDRec/Surface.h"
+#include "DDRec/DetectorData.h"
+#include "XML/Utilities.h"
+#include <cmath>
+
+#include "DetIdentifier/CEPCDetectorData.h"
+
+using namespace std;
+
+using dd4hep::Box;
+using dd4hep::Tube;
+using dd4hep::DetElement;
+using dd4hep::Material;
+using dd4hep::Position;
+using dd4hep::RotationY;
+using dd4hep::RotationZ;
+using dd4hep::RotationZYX;
+using dd4hep::Transform3D;
+using dd4hep::Rotation3D;
+using dd4hep::Volume;
+using dd4hep::_toString;
+using dd4hep::rec::volSurfaceList;
+using dd4hep::rec::ZPlanarData;
+using dd4hep::mm;
+
+/** Construction of the VXD detector, ported from Mokka driver SIT_Simple_Pixel.cc
+ *
+ *  Mokka History:
+ *  Feb 7th 2011, Steve Aplin - original version
+ *  F.Gaede, DESY, Jan 2014   - dd4hep SIT pixel
+ *  Hao Zeng, IHEP, July 2021
+ *  Chengdong FU, IHEP, Sep 2024 - composite from SiTrackerStaggeredLadder_v02 and SiTrackerStitching_v01
+ *  Tianyuan ZHANG, IHEP, Dec 2024 - add sensor detail based on SiTrackerComposite_v01
+ *  Chengdong FU, IHEP, Mar 2025 - change parameter input from SiTrackerComposite_v02
+ */
+
+static dd4hep::Ref_t create_element(dd4hep::Detector& theDetector, xml_h e, dd4hep::SensitiveDetector sens) {
+
+  xml_det_t  x_det    = e;
+  Material   air      = theDetector.air();
+  int        det_id   = x_det.id();
+  string     name     = x_det.nameStr();
+  DetElement det(name, det_id);
+
+  Volume envelope = dd4hep::xml::createPlacedEnvelope(theDetector, e, det);
+  dd4hep::xml::setDetectorTypeFlag(e, det) ;
+  if(theDetector.buildType()==dd4hep::BUILD_ENVELOPE) return det;
+  envelope.setVisAttributes(theDetector.visAttributes("SeeThrough"));
+
+  dd4hep::PrintLevel printLevel = dd4hep::ERROR;
+  if (x_det.hasAttr(_Unicode(printLevel))) {
+    printLevel = dd4hep::printLevel(x_det.attr<string>(_Unicode(printLevel)));
+  }
+  dd4hep::PrintLevel oldLevel = dd4hep::setPrintLevel(printLevel);
+
+  if (x_det.hasChild(_U(sensitive))) {
+    xml_dim_t sd_typ = x_det.child(_U(sensitive));
+    sens.setType(sd_typ.typeStr());
+  }
+  else {
+    sens.setType("tracker");
+  }
+
+  dd4hep::printout(dd4hep::INFO, "Construct", "** building SiTrackerComposite_v03 ...");
+
+  dd4hep::rec::CompositeData* compositeData = new dd4hep::rec::CompositeData;
+
+  //fetch the display parameters
+  xml_comp_t x_display(x_det.child(_Unicode(display)));
+  std::string ladderVis      = x_display.attr<string>(_Unicode(ladder));
+  std::string supportVis     = x_display.attr<string>(_Unicode(support));
+  std::string flexVis        = x_display.attr<string>(_Unicode(flex));
+  std::string sensEnvVis     = x_display.attr<string>(_Unicode(sens_env));
+  std::string sensVis        = x_display.attr<string>(_Unicode(sens));
+  std::string deadsensVis    = x_display.attr<string>(_Unicode(deadsensor));
+  std::string deadwireVis    = x_display.attr<string>(_Unicode(deadwire));
+
+  //fetch the shell parameters
+  if (x_det.hasChild(_Unicode(shell))) {
+    xml_comp_t x_shell(x_det.child(_Unicode(shell)));
+    double rmin_shell = x_shell.rmin();
+    double rmax_shell = x_shell.rmax();
+    double zhalf_shell = x_shell.zhalf();
+    Tube shellSolid(rmin_shell, rmax_shell, zhalf_shell);
+    Volume shellLogical(name + "_ShellLogical", shellSolid, theDetector.material(x_shell.materialStr()));
+    shellLogical.setVisAttributes(theDetector.visAttributes(x_shell.visStr()));
+    envelope.placeVolume(shellLogical);
+
+    compositeData->zHalfShell  = zhalf_shell;
+    compositeData->rInnerShell = rmin_shell;
+    compositeData->rOuterShell = rmax_shell;
+  }
+
+  for(xml_coll_t layer_i(x_det,_U(layer)); layer_i; ++layer_i){
+    xml_comp_t x_layer(layer_i);
+   
+    dd4hep::PlacedVolume pv;
+    int layer_id                 = x_layer.id();
+    bool isBent = false;
+    if (x_layer.hasAttr(_Unicode(isBent))) isBent = x_layer.attr<bool>(_Unicode(isBent));
+
+    dd4hep::printout(dd4hep::INFO, "Construct", "layer_id: %02d --- %s", layer_id, isBent ? "Stitching" : "Planar");
+
+    double z = x_layer.hasAttr(_U(z)) ? x_layer.z() : 0;
+
+    if (isBent) {
+      double phi0 = x_layer.phi0();
+
+      dd4hep::rec::CylindricalData::LayerLayout thisLayer;
+
+      int module_id = 0;
+      for (xml_coll_t module_i(x_layer, _U(module)); module_i; ++module_i) {
+	if (module_id>1) dd4hep::printout(dd4hep::ERROR, "Construct", "Not support more than two modules, possible wrong in reconstruction");
+
+	string name_module = name + dd4hep::_toString(layer_id, "_Layer%02d") + dd4hep::_toString(module_id, "_Stave%02d");
+	DetElement moduleDE(det, name_module, x_det.id());
+
+	xml_comp_t x_module(module_i);
+
+	double offset = x_module.offset();
+	double phi    = x_module.phi();
+
+	double radius = x_module.radius();
+	double backbone = x_module.attr<double>(_Unicode(backbone));
+	double switches = x_module.attr<double>(_Unicode(switches));
+	double bias = x_module.attr<double>(_Unicode(bias));
+	double periphery = x_module.attr<double>(_Unicode(periphery));
+	double mechanical_gap = x_module.attr<double>(_Unicode(mechanical_gap));
+	int nx = x_module.attr<int>(_Unicode(nx));
+	int ny = x_module.attr<int>(_Unicode(ny));
+	Material mat = theDetector.material(x_module.materialStr());
+
+	xml_comp_t x_sensor(x_module.child(_U(sensor)));
+	double sensor_thickness = x_sensor.thickness();
+	double sensor_width     = x_sensor.width();
+	double sensor_length    = x_sensor.length();
+	double sensor_dphi      = sensor_width/radius;
+	Material sensor_mat     = theDetector.material(x_sensor.materialStr());
+
+	Tube sensor_solid(radius, radius+sensor_thickness, sensor_length/2, -sensor_width/radius/2, sensor_width/radius/2);
+	Volume sensor_volume(name_module + "Sensor", sensor_solid, sensor_mat);
+	sensor_volume.setSensitiveDetector(sens);
+	if (x_det.hasAttr(_U(limits))) sensor_volume.setLimitSet(theDetector, x_det.limitsStr());
+	sensor_volume.setVisAttributes(theDetector.visAttributes(x_sensor.visStr()));
+
+	xml_comp_t x_flex(x_module.child(_Unicode(flex)));
+	std::vector<std::pair<double, Material> > flexs;
+	double flex_thickness = 0;
+	for (xml_coll_t slice_i(x_flex, _U(slice)); slice_i; ++slice_i) {
+	  xml_comp_t x_slice(slice_i);
+	  double thickness   = x_slice.thickness();
+	  Material mat_slice = theDetector.material(x_slice.materialStr());
+	  flexs.push_back(std::make_pair(thickness, mat_slice));
+	  flex_thickness += thickness;
+	  dd4hep::printout(dd4hep::DEBUG, "Construct", "flex %s: %f mm", mat_slice.name(), thickness/dd4hep::mm);
+	}
+	double flex_width  = (sensor_width+periphery)*ny + bias*ny/2;
+	double flex_length = (sensor_length+switches)*nx + backbone*nx/3 + mechanical_gap;
+	double flex_radius = radius+sensor_thickness;
+	double flex_dphi   = flex_width/radius;
+	Tube flex_solid(flex_radius, flex_radius+flex_thickness, flex_length/2, -flex_dphi/2, flex_dphi/2);
+	Volume flex_volume(name_module + "Flex", flex_solid, air);
+	flex_volume.setVisAttributes(theDetector.visAttributes(x_flex.visStr()));
+	double start_radius = flex_radius;
+	for (unsigned islice=0; islice<flexs.size(); islice++) {
+	  dd4hep::printout(dd4hep::DEBUG, "Construct", "flex start radius: %f mm", start_radius/dd4hep::mm);
+	  Tube slice_solid(start_radius, start_radius+flexs[islice].first, flex_length/2, -flex_dphi/2, flex_dphi/2);
+	  Volume slice_volume(name_module + dd4hep::_toString(int(islice), "Flex_%d"), slice_solid, flexs[islice].second);
+	  flex_volume.placeVolume(slice_volume);
+	  start_radius += flexs[islice].first;
+	}
+
+	double service_radius = radius + sensor_thickness;
+
+	// in fact driver, the left impact as name of readout
+	xml_comp_t x_readout(x_module.child(_Unicode(readout)));
+	double readout_thickness = x_readout.thickness();
+	double readout_length = x_readout.width();
+	double readout_width  = flex_width;
+	double readout_dphi  = readout_width/radius;
+	Material readout_mat = theDetector.material(x_readout.materialStr());
+	Tube readout_solid(service_radius, service_radius+readout_thickness, readout_length/2, -flex_dphi/2, flex_dphi/2);
+	Volume readout_volume(name_module + "DriverL", readout_solid, readout_mat);
+	readout_volume.setVisAttributes(theDetector.visAttributes(x_readout.visStr()));
+
+	xml_comp_t x_driver(x_module.child(_Unicode(driver)));
+        double driver_thickness = x_driver.thickness();
+        double driver_length = x_driver.width();
+        double driver_width  = flex_width;
+        double driver_dphi  = driver_width/radius;
+        Material driver_mat = theDetector.material(x_driver.materialStr());
+        Tube driver_solid(service_radius, service_radius+driver_thickness, driver_length/2, -flex_dphi/2, flex_dphi/2);
+        Volume driver_volume(name_module + "DriverR", driver_solid, driver_mat);
+        driver_volume.setVisAttributes(theDetector.visAttributes(x_driver.visStr()));
+
+	double module_length = flex_length + readout_length + driver_length;
+	double module_width  = flex_width;
+	double module_dphi   = module_width/radius;
+	double module_thickness = sensor_thickness + std::max(flex_thickness, std::max(readout_thickness,driver_thickness));
+	Tube module_solid(radius, radius+module_thickness, module_length/2, -flex_dphi/2, flex_dphi/2);
+	Volume module_volume(name_module, module_solid, air);
+	module_volume.setVisAttributes(theDetector.visAttributes("SeeThrough"));
+
+	Tube board_solid(radius, radius+sensor_thickness, module_length/2, -flex_dphi/2, flex_dphi/2);
+	Volume board_volume(name_module + "Board", board_solid, mat);
+	board_volume.setVisAttributes(theDetector.visAttributes(x_module.visStr()));
+	module_volume.placeVolume(board_volume);
+
+	double z_bent = 0.0;
+	double delta = 0.0;
+	for (int ix = 0; ix < nx; ix++) {
+	    if (ix < nx / 2) {
+		z_bent = -flex_length/2 + sensor_length/2 + (static_cast<int>(ix/3) + 1)*backbone + ix*(sensor_length + switches);
+	    }
+	    else {
+		z_bent = -flex_length/2 + sensor_length/2 + (static_cast<int>(ix/3) + 1)*backbone + ix*(sensor_length + switches) + mechanical_gap;
+	    }
+	    for (int iy = 0; iy < ny; iy++) {
+	        if (iy % 2 != 0) {
+		    delta = -flex_dphi/2 + sensor_dphi/2 + iy*(sensor_dphi + periphery/radius) + ((iy + 1)/2)*bias/radius;
+	        }
+	        else {
+		    delta = -flex_dphi/2 + sensor_dphi/2 + iy*sensor_dphi + (iy + 1)*periphery / radius + iy/2*bias/radius;
+	        }
+		Transform3D tran(RotationZ(delta), Position(0, 0, z_bent));
+		dd4hep::PlacedVolume pv = board_volume.placeVolume(sensor_volume, tran);
+
+		int sensor_id = ix + nx*iy;
+		pv.addPhysVolID("sensor", sensor_id);
+		dd4hep::rec::Vector3D ocyl(radius + 0.5 * sensor_thickness, 0., 0.);
+		dd4hep::rec::VolCylinder surf(sensor_volume, dd4hep::rec::SurfaceType(dd4hep::rec::SurfaceType::Sensitive),
+		0.5 * sensor_thickness, module_thickness - 0.5 * sensor_thickness, ocyl);
+		DetElement sensorDE(moduleDE, name_module + dd4hep::_toString(sensor_id, "_Sensor%02d"), x_det.id());
+		sensorDE.setPlacement(pv);
+		volSurfaceList(sensorDE)->push_back(surf);
+	  }
+        }
+
+	module_volume.placeVolume(flex_volume, Position(0, 0, readout_length/2-driver_length/2));
+	module_volume.placeVolume(readout_volume, Position(0, 0, -flex_length/2-driver_length/2));
+	module_volume.placeVolume(driver_volume, Position(0, 0,  flex_length/2+readout_length/2));
+
+	if (module_id == 0) {
+	  thisLayer.zHalf              = flex_length/2.0;
+	  thisLayer.radiusSensitive    = radius;
+	  thisLayer.thicknessSensitive = sensor_thickness;
+	  thisLayer.radiusSupport      = flex_radius;
+	  thisLayer.thicknessSupport   = flex_thickness;
+	  thisLayer.width              = flex_width;
+	  thisLayer.phi0 = phi0 + phi;
+	  thisLayer.rgap = radius;
+	}
+	else {
+	  thisLayer.rgap = radius - thisLayer.rgap;
+          thisLayer.dphi = phi0 + phi - thisLayer.phi0;
+        }
+
+	Transform3D tran(RotationZ(phi0+phi), Position(offset*cos(phi), offset*sin(phi), z));
+	pv = envelope.placeVolume(module_volume, tran);
+	pv.addPhysVolID("layer", layer_id).addPhysVolID("module", module_id);
+
+	moduleDE.setPlacement(pv);
+
+	module_id++;
+      }
+
+      compositeData->layersBent.push_back(thisLayer);
+    }
+    else {
+      double support_rmin         = x_layer.attr<double>(_Unicode(support_rmin));
+      int    n_sensors_per_ladder = x_layer.attr<int>(_Unicode(n_sensors_per_side));
+      int    n_ladders            = x_layer.attr<int>(_Unicode(n_ladders)) ;
+      double rotate               = x_layer.attr<double>(_Unicode(rotate));
+      double phi0                 = x_layer.attr<double>(_Unicode(phi0));
+
+      std::string layerName = dd4hep::_toString(layer_id , "layer_%02d");
+      dd4hep::Assembly layer_assembly(layerName);
+      pv = envelope.placeVolume(layer_assembly);
+      dd4hep::DetElement layerDE(det, layerName, x_det.id());
+      layerDE.setPlacement(pv);
+    
+      const double ladder_dphi = ( dd4hep::twopi / n_ladders ) ;
+      dd4hep::printout(dd4hep::DEBUG, "Construct", "ladder_dphi: %f (%f degree)", ladder_dphi, ladder_dphi/dd4hep::degree);
+    
+      //fetch the ladder parameters
+      xml_comp_t x_ladder(x_layer.child(_Unicode(ladder)));
+    
+      //fetch the ladder support parameters
+      xml_comp_t x_ladder_support(x_ladder.child(_Unicode(ladderSupport)));
+      double support_length        = x_ladder_support.attr<double>(_Unicode(length));
+      double support_thickness     = x_ladder_support.attr<double>(_Unicode(thickness));
+      double support_height        = x_ladder_support.attr<double>(_Unicode(height));
+      double support_width         = x_ladder_support.attr<double>(_Unicode(width));
+      Material support_mat;
+      if(x_ladder_support.hasAttr(_Unicode(mat))) {
+	support_mat = theDetector.material(x_ladder_support.attr<string>(_Unicode(mat)));
+      }
+      else {
+	support_mat = theDetector.material(x_ladder_support.materialStr());
+      }
+      dd4hep::printout(dd4hep::INFO, "Construct", "support_length = %f mm, support_thickness = %f mm, support_width = %f mm", support_length/mm, support_thickness/mm, support_width/mm);
+
+      double ladder_offset   = - support_rmin*sin(rotate) - support_width/2.0;
+      double ladder_distance = support_rmin*cos(rotate) + support_height/2.0;
+      double ladder_radius   = sqrt(ladder_offset*ladder_offset + ladder_distance*ladder_distance);
+      double ladder_phi0     = phi0 + atan(ladder_offset/ladder_distance);
+      dd4hep::printout(dd4hep::INFO, "Construct", "ladder_radius = %f mm, ladder_distance = %f mm, ladder_offset = %f mm, n_sensors_per_ladder = %d",
+		       ladder_radius/mm, ladder_distance/mm, ladder_offset/mm, n_sensors_per_ladder);
+
+      //fetch the flex parameters
+      double flex_thickness(0);
+      double flex_width(0);
+      double flex_length(0);
+      xml_comp_t x_flex(x_ladder.child(_Unicode(flex)));
+      for(xml_coll_t flex_i(x_flex,_U(slice)); flex_i; ++flex_i) {
+	xml_comp_t x_flex_slice(flex_i);
+	double x_flex_slice_thickness = x_flex_slice.attr<double>(_Unicode(thickness));
+	double x_flex_slice_width = x_flex_slice.attr<double>(_Unicode(width));
+	double x_flex_slice_length = x_flex_slice.attr<double>(_Unicode(length));
+	flex_thickness += x_flex_slice_thickness;
+	if (x_flex_slice_width > flex_width) flex_width = x_flex_slice_width;
+	if (x_flex_slice_length > flex_length) flex_length = x_flex_slice_length;
+	dd4hep::printout(dd4hep::DEBUG, "Construct", "x_flex_slice_thickness: %f mm", x_flex_slice_thickness/mm);
+      }
+      dd4hep::printout(dd4hep::INFO, "Construct", "flex_length = %f mm, flex_thickness = %f mm, flex_width = %f mm", flex_length/mm, flex_thickness/mm, flex_width/mm);
+
+      //fetch the sensor parameters
+      xml_comp_t x_sensor(x_ladder.child(_Unicode(sensor)));
+      int n_sensors_per_side                  = x_sensor.attr<int>(_Unicode(n_sensors));
+      double dead_gap                         = x_sensor.attr<double>(_Unicode(gap));
+      double sensor_thickness                 = x_sensor.attr<double>(_Unicode(thickness));
+      double sensor_active_len                = x_sensor.attr<double>(_Unicode(active_length));
+      double sensor_active_width              = x_sensor.attr<double>(_Unicode(active_width));
+      double sensor_dead_width                = x_sensor.attr<double>(_Unicode(dead_width));
+      double sensor_deadwire_length           = x_sensor.attr<double>(_Unicode(deadwire_length));
+      double sensor_deadwire_width            = x_sensor.attr<double>(_Unicode(deadwire_width));
+      double sensor_deadwire_thickness        = x_sensor.attr<double>(_Unicode(deadwire_thickness));
+      Material sensor_mat                     = theDetector.material(x_sensor.attr<string>(_Unicode(sensor_mat)));
+      Material sensor_deadwire_mat            = theDetector.material(x_sensor.attr<string>(_Unicode(deadwire_mat)));
+
+      dd4hep::printout(dd4hep::INFO, "Construct", "sensor_active_length = %f mm, sensor_thickness = %f mm, sensor_active_width = %f mm", sensor_active_len/mm, sensor_thickness/mm, sensor_active_width/mm);
+      dd4hep::printout(dd4hep::INFO, "Construct", "sensor_dead_width = %f mm, dead_gap = %f mm, n_sensors_per_side = %d", sensor_dead_width/mm, dead_gap/mm, n_sensors_per_side);
+
+      //create ladder logical volume
+      Box LadderSolid((support_height+2*sensor_thickness+2*flex_thickness)/2.0, support_width/2.0, support_length/2.0);
+      Volume LadderLogical(name + dd4hep::_toString(layer_id, "_LadderLogical_%02d"), LadderSolid, air);
+      // create flex envelope logical volume
+      Box FlexEnvelopeSolid(flex_thickness/2.0, flex_width/2.0, flex_length/2.0);
+      Volume FlexEnvelopeLogical(name + dd4hep::_toString( layer_id, "_FlexEnvelopeLogical_%02d"), FlexEnvelopeSolid, air);
+      FlexEnvelopeLogical.setVisAttributes(theDetector.visAttributes("SeeThrough"));
+
+      //create the flex layers inside the flex envelope
+      double flex_start_height(-flex_thickness/2.); 
+      int index = 0;
+      for(xml_coll_t flex_i(x_flex,_U(slice)); flex_i; ++flex_i){
+	xml_comp_t x_flex_slice(flex_i);
+	double x_flex_slice_thickness = x_flex_slice.attr<double>(_Unicode(thickness));
+	double x_flex_slice_width = x_flex_slice.attr<double>(_Unicode(width));
+	double x_flex_slice_length = x_flex_slice.attr<double>(_Unicode(length));
+	Material x_flex_slice_mat;
+	if(x_flex_slice.hasAttr(_Unicode(mat))) {
+	  x_flex_slice_mat = theDetector.material(x_flex_slice.attr<string>(_Unicode(mat)));
+	}
+	else {
+	  x_flex_slice_mat = theDetector.material(x_flex_slice.materialStr());
+	}
+	// Material x_flex_slice_mat = theDetector.material(x_flex_slice.attr<string>(_Unicode(mat)));
+	Box FlexLayerSolid(x_flex_slice_thickness/2.0, x_flex_slice_width/2.0, x_flex_slice_length/2.0);
+	Volume FlexLayerLogical(name + dd4hep::_toString( layer_id, "_FlexLayerLogical_%02d") + dd4hep::_toString( index, "index_%02d"), FlexLayerSolid, x_flex_slice_mat);
+	FlexLayerLogical.setVisAttributes(theDetector.visAttributes(flexVis));
+	double flex_slice_height = flex_start_height + x_flex_slice_thickness/2.;
+	pv = FlexEnvelopeLogical.placeVolume(FlexLayerLogical, Position(flex_slice_height, 0., 0.));
+	flex_start_height += x_flex_slice_thickness;
+	index++;
+      }
+
+      //place the flex envelope inside the ladder envelope
+      pv = LadderLogical.placeVolume(FlexEnvelopeLogical, Position((support_height + flex_thickness)/2.0, 0., 0.)); //top side
+      //define the transformation3D(only need a combination of translation and rotation)
+      Transform3D tran_mirro(RotationZYX(0., dd4hep::twopi/2.0, 0.), Position(-(support_height + flex_thickness)/2.0, 0., 0.));
+      pv = LadderLogical.placeVolume(FlexEnvelopeLogical, tran_mirro); //bottom side
+
+      //create sensor envelope logical volume
+      Box SensorTopEnvelopeSolid(sensor_thickness/2.0, support_width/2.0, support_length/2.0);
+      Volume SensorTopEnvelopeLogical(name + dd4hep::_toString( layer_id, "_SensorEnvelopeLogical_%02d"), SensorTopEnvelopeSolid, air);
+      Box SensorBottomEnvelopeSolid(sensor_thickness/2.0, support_width/2.0, support_length/2.0);
+      Volume SensorBottomEnvelopeLogical(name + dd4hep::_toString(layer_id, "_SensorEnvelopeLogical_%02d"), SensorBottomEnvelopeSolid, air);
+      SensorTopEnvelopeLogical.setVisAttributes(theDetector.visAttributes(sensEnvVis));
+
+      //create sensor logical volume
+      Box SensorSolid(sensor_thickness/2.0, sensor_active_width/2.0, sensor_active_len/2.0);
+      Volume SensorTopLogical(name + dd4hep::_toString(layer_id+1, "_SensorLogical_%02d"), SensorSolid, sensor_mat);
+      Volume SensorBottomLogical(name + dd4hep::_toString(layer_id, "_SensorLogical_%02d"), SensorSolid, sensor_mat);
+      SensorTopLogical.setSensitiveDetector(sens);
+      SensorBottomLogical.setSensitiveDetector(sens);
+      if (x_det.hasAttr(_U(limits))) {
+	SensorTopLogical.setLimitSet(theDetector, x_det.limitsStr());
+	SensorBottomLogical.setLimitSet(theDetector, x_det.limitsStr());
+      }
+      SensorTopLogical.setVisAttributes(theDetector.visAttributes(sensVis));
+      SensorBottomLogical.setVisAttributes(theDetector.visAttributes(sensVis));
+
+      //create dead sensor logical volume
+      Box SensorDeadSolid(sensor_thickness / 2.0, sensor_dead_width / 2.0, sensor_active_len / 2.0);
+      Volume SensorDeadLogical(name + dd4hep::_toString( layer_id, "_SensorDeadLogical_%02d"), SensorDeadSolid, sensor_mat);
+      SensorDeadLogical.setVisAttributes(theDetector.visAttributes(deadsensVis));
+
+      //create dead wire logical volume
+      Box SensorDeadWireSolid(sensor_deadwire_thickness / 2.0, sensor_deadwire_width / 2.0, sensor_deadwire_length / 2.0);
+      Volume SensorDeadWireLogical(name + dd4hep::_toString( layer_id, "_SensorDeadWireLogical_%02d"), SensorDeadWireSolid, sensor_deadwire_mat);
+      SensorDeadWireLogical.setVisAttributes(theDetector.visAttributes(deadwireVis));
+
+      //place the dead wire in the sensor envelope
+      // pv = SensorTopEnvelopeLogical.placeVolume(SensorDeadWireLogical, Position(0.0, (sensor_active_width-support_width/2.0) + sensor_dead_width/2.0 + sensor_deadwire_width/2.0, 0.0));
+      // pv = SensorBottomEnvelopeLogical.placeVolume(SensorDeadWireLogical, Position(0.0, (sensor_active_width-support_width/2.0) + sensor_dead_width/2.0 + sensor_deadwire_width/2.0, 0.0));
+      pv = SensorTopEnvelopeLogical.placeVolume(SensorDeadWireLogical, Position(0.0, (-support_width/2.0) + (sensor_deadwire_width/2.0), 0.0));
+      pv = SensorBottomEnvelopeLogical.placeVolume(SensorDeadWireLogical, Position(0.0, (-support_width/2.0) + (sensor_deadwire_width/2.0), 0.0));
+
+      // place the active sensor and dead sensor inside the sensor envelope
+      std::vector<dd4hep::PlacedVolume> TopSensor_pv;
+      std::vector<dd4hep::PlacedVolume> BottomSensor_pv;
+      for(int isensor=0; isensor < n_sensors_per_side; ++isensor){
+	double sensor_total_z = n_sensors_per_side*sensor_active_len + dead_gap*(n_sensors_per_side-1);
+	double xpos = 0.0;
+	double ypos_active = (support_width/2.0) - (sensor_active_width/2.0);
+	double ypos_dead = (-support_width/2.0) + sensor_deadwire_width + (sensor_dead_width/2.0);
+	double zpos = -sensor_total_z/2.0 + sensor_active_len/2.0 + isensor*(sensor_active_len + dead_gap);
+	pv = SensorTopEnvelopeLogical.placeVolume(SensorTopLogical, Position(xpos,ypos_active,zpos));
+	//pv.addPhysVolID("topsensor",  isensor ) ;
+	pv.addPhysVolID("layer", layer_id+1).addPhysVolID("sensor", isensor);
+	TopSensor_pv.push_back(pv);
+	pv = SensorBottomEnvelopeLogical.placeVolume(SensorBottomLogical, Position(xpos,ypos_active,zpos));
+	//pv.addPhysVolID("bottomsensor",  isensor ) ;
+	pv.addPhysVolID("layer", layer_id  ).addPhysVolID("sensor", isensor);
+	BottomSensor_pv.push_back(pv);
+	pv = SensorTopEnvelopeLogical.placeVolume(SensorDeadLogical, Position(xpos,ypos_dead,zpos));
+	pv = SensorBottomEnvelopeLogical.placeVolume(SensorDeadLogical, Position(xpos,ypos_dead,zpos));
+      }
+      //place the sensor envelope inside the ladder envelope
+      pv = LadderLogical.placeVolume(SensorTopEnvelopeLogical,
+				     Position(support_height/2.0 + flex_thickness + sensor_thickness/2.0, 0., 0.));//top-side sensors
+      Position pos(-(support_height/2.0 + flex_thickness + sensor_thickness/2.0), 0., 0.);
+      pv = LadderLogical.placeVolume(SensorBottomEnvelopeLogical, pos);//bottom-side sensors
+    
+      //create the ladder support
+      Box LadderSupportSolid(support_height/2.0, support_width/2.0, support_length/2.0);
+      Volume LadderSupportLogical(name + _toString( layer_id,"_SupLogical_%02d"), LadderSupportSolid, support_mat);
+      LadderSupportLogical.setVisAttributes(theDetector.visAttributes(supportVis));
+
+      //create ladder support cavity
+      Box LadderSupportCavitySolid(support_height/2.0-support_thickness/2.0, support_width/2.0-support_thickness/2.0, support_length/2.0);
+      Volume LadderSupportCavityLogical(name + _toString( layer_id,"_SupCavityLogical_%02d"), LadderSupportCavitySolid, air);
+      LadderSupportCavityLogical.setVisAttributes(theDetector.visAttributes("SeeThrough"));
+
+      pv = LadderSupportLogical.placeVolume(LadderSupportCavityLogical);
+      pv = LadderLogical.placeVolume(LadderSupportLogical);
+
+      for(int i = 0; i < n_ladders; i++){
+	std::stringstream ladder_enum; 
+	ladder_enum << "vxt_ladder_" << layer_id << "_" << i;
+	DetElement ladderDE(layerDE, ladder_enum.str(), x_det.id());
+	dd4hep::printout(dd4hep::DEBUG, "Construct", "start building %s", ladder_enum.str().c_str());
+
+	//====== create the meassurement surface ===================
+	dd4hep::rec::Vector3D o(0,0,0);
+	dd4hep::rec::Vector3D u( 0., 1., 0.);
+	dd4hep::rec::Vector3D v( 0., 0., 1.);
+	dd4hep::rec::Vector3D n( 1., 0., 0.);
+	// fucd: SensorLogical only sensor_thickness, support need another surface, todo
+	double inner_thick_top = sensor_thickness/2.0;
+	double outer_thick_top = sensor_thickness/2.0;//support_height/2.0 + flex_thickness + sensor_thickness/2.0;
+	double inner_thick_bottom = sensor_thickness/2.0;//support_height/2.0 + flex_thickness + sensor_thickness/2.0;
+	double outer_thick_bottom = sensor_thickness/2.0;
+	dd4hep::rec::VolPlane surfTop(SensorTopLogical,
+				      dd4hep::rec::SurfaceType(dd4hep::rec::SurfaceType::Sensitive),
+				      inner_thick_top, outer_thick_top, u, v, n, o);
+	dd4hep::rec::VolPlane surfBottom(SensorBottomLogical,
+					 dd4hep::rec::SurfaceType(dd4hep::rec::SurfaceType::Sensitive),
+					 inner_thick_bottom, outer_thick_bottom, u, v, n, o);
+
+	for(int isensor=0; isensor < n_sensors_per_side; ++isensor){
+	  std::stringstream topsensor_str;
+	  std::stringstream bottomsensor_str;
+	  topsensor_str << ladder_enum.str() << "_top_" << isensor;
+	  // std::cout << "\tstart building " << topsensor_str.str() << ":" << endl;
+	  bottomsensor_str << ladder_enum.str() << "_bottom_" << isensor;
+	  // std::cout << "\tstart building " << bottomsensor_str.str() << ":" << endl;
+	  DetElement topsensorDE(ladderDE, topsensor_str.str(), x_det.id());
+	  DetElement bottomsensorDE(ladderDE, bottomsensor_str.str(), x_det.id());
+	  topsensorDE.setPlacement(TopSensor_pv[isensor]);
+	  volSurfaceList(topsensorDE)->push_back(surfTop);
+	  // std::cout << "\t" << topsensor_str.str() << " done." << endl;
+	  bottomsensorDE.setPlacement(BottomSensor_pv[isensor]);
+	  // std::cout << "\t" << bottomsensor_str.str() << " done." << endl;
+	  volSurfaceList(bottomsensorDE)->push_back(surfBottom);
+	}
+	Transform3D tr (RotationZYX(rotate+ladder_dphi*i,0.,0.),Position(ladder_radius*cos(ladder_phi0+ladder_dphi*i), ladder_radius*sin(ladder_phi0+ladder_dphi*i), 0.));
+	pv = layer_assembly.placeVolume(LadderLogical,tr);
+	pv.addPhysVolID("module", i ) ; 
+	ladderDE.setPlacement(pv);
+	dd4hep::printout(dd4hep::DEBUG, "Construct", "%s done.", ladder_enum.str().c_str());
+	if(i==0) dd4hep::printout(dd4hep::DEBUG, "Construct", "(x,y) = (%f, %f)mm", ladder_radius*cos(ladder_phi0)/mm, ladder_radius*sin(ladder_phi0)/mm);
+      }
+
+      // package the reconstruction data
+      dd4hep::rec::ZPlanarData::LayerLayout topLayer;
+      dd4hep::rec::ZPlanarData::LayerLayout bottomLayer;
+
+      topLayer.ladderNumber         = n_ladders;
+      topLayer.phi0                 = phi0;
+      topLayer.sensorsPerLadder     = n_sensors_per_side;
+      topLayer.lengthSensor         = sensor_active_len;
+      topLayer.distanceSupport      = ladder_distance + support_height / 2.0 - support_thickness / 2.0;
+      topLayer.thicknessSupport     = support_thickness / 2.0 + flex_thickness;
+      topLayer.offsetSupport        = ladder_offset;
+      topLayer.widthSupport         = support_width;
+      topLayer.zHalfSupport         = support_length / 2.0;
+      topLayer.distanceSensitive    = ladder_distance + support_height / 2.0 + flex_thickness;
+      topLayer.thicknessSensitive   = sensor_thickness;
+      topLayer.offsetSensitive      = ladder_offset + (support_width/2.0 - sensor_active_width/2.0 - sensor_dead_width/2.0);
+      topLayer.widthSensitive       = sensor_active_width + sensor_dead_width;
+      topLayer.zHalfSensitive       = (n_sensors_per_side*(sensor_active_len + dead_gap) - dead_gap) / 2.0;
+
+      bottomLayer.ladderNumber         = n_ladders;
+      bottomLayer.phi0                 = phi0;
+      bottomLayer.sensorsPerLadder     = n_sensors_per_side;
+      bottomLayer.lengthSensor         = sensor_active_len;
+      bottomLayer.distanceSupport      = ladder_distance - support_height / 2.0 - flex_thickness;
+      bottomLayer.thicknessSupport     = support_thickness / 2.0 + flex_thickness;
+      bottomLayer.offsetSupport        = ladder_offset;
+      bottomLayer.widthSupport         = support_width;
+      bottomLayer.zHalfSupport         = support_length / 2.0;
+      bottomLayer.distanceSensitive    = ladder_distance - support_height / 2.0 - sensor_thickness - flex_thickness;
+      bottomLayer.thicknessSensitive   = sensor_thickness;
+      bottomLayer.offsetSensitive      = ladder_offset + (support_width/2.0 - sensor_active_width/2.0 - sensor_dead_width/2.0);
+      bottomLayer.widthSensitive       = sensor_active_width + sensor_dead_width;
+      bottomLayer.zHalfSensitive       = (n_sensors_per_side*(sensor_active_len + dead_gap) - dead_gap) / 2.0;
+
+      compositeData->layersPlanar.push_back(bottomLayer);
+      compositeData->layersPlanar.push_back(topLayer);
+    }
+  }
+  if (dd4hep::printLevel()<=dd4hep::WARNING) std::cout << (*compositeData) << endl;
+  det.addExtension<dd4hep::rec::CompositeData>(compositeData);
+
+  if (x_det.hasAttr(_U(combineHits))) det.setCombineHits(x_det.attr<bool>(_U(combineHits)),sens);
+
+  dd4hep::printout(dd4hep::INFO, "Construct", "SiTrackerComposite_v03 done."); 
+  dd4hep::setPrintLevel(oldLevel);
+
+  return det;
+}
+DECLARE_DETELEMENT(SiTrackerComposite_v03,create_element)