/** Construction of VTX detector, ported from Mokka driver TubeX01.cc * * Mokka History: * - first implementation as Tube00: Paulo Mora de Freitas, Sep 2002 * - modified from Tube00 to Tube01DT: Ties Behnke, 2003-02-11 * - modified for a crossing angle as TubeX00: Adrian Vogel, 2005-05-18 * - modified for fancier geometries as TubeX01: Adrian Vogel, 2006-04-20 * * @author: F.Gaede, DESY, Jan 2014 * */ static Ref_t create_element(Detector& theDetector, xml_h element, SensitiveDetector /*sens*/) { //------------------------------------------ // See comments starting with '//**' for // hints on porting issues //------------------------------------------ std::cout << "This is the Beampipe:" << std::endl; //Access to the XML File xml_det_t xmlBeampipe = element; const std::string name = xmlBeampipe.nameStr(); DetElement tube( name, xmlBeampipe.id() ) ; // --- create an envelope volume and position it into the world --------------------- Volume envelope = dd4hep::xml::createPlacedEnvelope( theDetector, element , tube ) ; dd4hep::xml::setDetectorTypeFlag( element, tube ) ; if( theDetector.buildType() == BUILD_ENVELOPE ) return tube ; //----------------------------------------------------------------------------------- ConicalSupportData* beampipeData = new ConicalSupportData ; //###################################################################################################################################################################### // code ported from TubeX01::construct() : //################################## //** DD4hep/TGeo seems to need rad (as opposed to the manual) const double phi1 = 0 ; const double phi2 = 360.0*dd4hep::degree; //Parameters we have to know about dd4hep::xml::Component xmlParameter = xmlBeampipe.child(_Unicode(parameter)); const double crossingAngle = xmlParameter.attr< double >(_Unicode(crossingangle))*0.5; // only half the angle double min_radius = 1.e99 ; for(xml_coll_t c( xmlBeampipe ,Unicode("section")); c; ++c) { xml_comp_t xmlSection( c ); ODH::ECrossType crossType = ODH::getCrossType(xmlSection.attr< std::string >(_Unicode(type))); const double zStart = xmlSection.attr< double > (_Unicode(start)); const double zEnd = xmlSection.attr< double > (_Unicode(end)); const double rInnerStart = xmlSection.attr< double > (_Unicode(rMin1)); const double rInnerEnd = xmlSection.attr< double > (_Unicode(rMin2)); const double rOuterStart = xmlSection.attr< double > (_Unicode(rMax1)); const double rOuterEnd = xmlSection.attr< double > (_Unicode(rMax2)); const double thickness = rOuterStart - rInnerStart; Material sectionMat = theDetector.material(xmlSection.materialStr()); const std::string volName = "tube_" + xmlSection.nameStr(); std::cout << std::setw(8) << zStart /dd4hep::mm << std::setw(8) << zEnd /dd4hep::mm << std::setw(8) << rInnerStart /dd4hep::mm << std::setw(8) << rInnerEnd /dd4hep::mm << std::setw(8) << rOuterStart /dd4hep::mm << std::setw(8) << rOuterEnd /dd4hep::mm << std::setw(8) << thickness /dd4hep::mm << std::setw(8) << crossType << std::setw(35) << volName << std::setw(15) << sectionMat.name() << std::endl; if( crossType == ODH::kCenter ) { // store only the central sections ! ConicalSupportData::Section section ; section.rInner = rInnerStart ; section.rOuter = rOuterStart ; section.zPos = zStart ; beampipeData->sections.push_back( section ) ; } // things which can be calculated immediately const double zHalf = fabs(zEnd - zStart) * 0.5; // half z length of the cone const double zPosition = fabs(zEnd + zStart) * 0.5; // middle z position Material coreMaterial = theDetector.material("beam"); // always the same Material wallMaterial = sectionMat; // this could mess up your geometry, so better check it if (not checkForSensibleGeometry(crossingAngle, crossType)){ throw std::runtime_error( " Beampipe_o1_v01_geo.cpp : checkForSensibleGeometry() failed " ) ; // return false; } const double rotateAngle = getCurrentAngle(crossingAngle, crossType); // for the placement at +z (better make it const now) const double mirrorAngle = M_PI - rotateAngle; // for the "mirrored" placement at -z // the "mirroring" in fact is done by a rotation of (almost) 180 degrees around the y-axis switch (crossType) { case ODH::kCenter: case ODH::kUpstream: case ODH::kDnstream: { // a volume on the z-axis, on the upstream branch, or on the downstream branch // absolute transformations for the placement in the world Transform3D transformer(RotationY(rotateAngle), RotateY( Position(0, 0, zPosition), rotateAngle) ); Transform3D transmirror(RotationY(mirrorAngle), RotateY( Position(0, 0, zPosition), mirrorAngle) ); // solid for the tube (including vacuum and wall): a solid cone ConeSegment tubeSolid( zHalf, 0, rOuterStart, 0, rOuterEnd , phi1, phi2); // tube consists of vacuum // place tube twice explicitely so we can attach surfaces to each one Volume tubeLog( volName, tubeSolid, coreMaterial ) ; Volume tubeLog2( volName, tubeSolid, coreMaterial ) ; // placement of the tube in the world, both at +z and -z envelope.placeVolume( tubeLog, transformer ); envelope.placeVolume( tubeLog2, transmirror ); // if inner and outer radii are equal, then omit the tube wall if (rInnerStart != rOuterStart || rInnerEnd != rOuterEnd) { // the wall solid: a tubular cone ConeSegment wallSolid( zHalf, rInnerStart, rOuterStart, rInnerEnd, rOuterEnd, phi1, phi2); // the wall consists of the material given in the XML Volume wallLog ( volName + "_wall", wallSolid, wallMaterial); Volume wallLog2( volName + "_wall2", wallSolid, wallMaterial); if( crossType == ODH::kCenter ) { // add surface for tracking .... const bool isCylinder = ( rInnerStart == rInnerEnd ); if (isCylinder) { // cylinder Vector3D ocyl( rInnerStart + thickness/2. , 0. , 0. ) ; VolCylinder cylSurf1( wallLog , SurfaceType( SurfaceType::Helper ) , 0.5*thickness , 0.5*thickness , ocyl ); VolCylinder cylSurf2( wallLog2, SurfaceType( SurfaceType::Helper ) , 0.5*thickness , 0.5*thickness , ocyl ); volSurfaceList( tube )->push_back( cylSurf1 ); volSurfaceList( tube )->push_back( cylSurf2 ); }else{ // cone const double dr = rInnerEnd - rInnerStart ; const double theta = atan2( dr , 2.* zHalf ) ; Vector3D ocon( rInnerStart + 0.5 * ( dr + thickness ), 0. , 0. ); Vector3D v( 1. , 0. , theta, Vector3D::spherical ) ; VolCone conSurf1( wallLog , SurfaceType( SurfaceType::Helper ) , 0.5*thickness , 0.5*thickness , v, ocon ); VolCone conSurf2( wallLog2, SurfaceType( SurfaceType::Helper ) , 0.5*thickness , 0.5*thickness , v, ocon ); volSurfaceList( tube )->push_back( conSurf1 ); volSurfaceList( tube )->push_back( conSurf2 ); } if( rInnerStart < min_radius ) min_radius = rInnerStart ; if( rOuterStart < min_radius ) min_radius = rOuterStart ; } wallLog.setVisAttributes(theDetector, "TubeVis"); wallLog2.setVisAttributes(theDetector, "TubeVis"); tubeLog.setVisAttributes(theDetector, "VacVis"); tubeLog2.setVisAttributes(theDetector, "VacVis"); // placement as a daughter volume of the tube, will appear in both placements of the tube tubeLog.placeVolume( wallLog, Transform3D() ); tubeLog2.placeVolume( wallLog2, Transform3D() ); } } break; case ODH::kPunchedCenter: { // a volume on the z-axis with one or two inner holes // (implemented as a cone from which tubes are punched out) const double rUpstreamPunch = rInnerStart; // just alias names denoting what is meant here const double rDnstreamPunch = rInnerEnd; // (the database entries are "abused" in this case) // relative transformations for the composition of the SubtractionVolumes Transform3D upstreamTransformer(RotationY(-crossingAngle), Position(zPosition * tan(-crossingAngle), 0, 0)); Transform3D dnstreamTransformer(RotationY(+crossingAngle), Position(zPosition * tan(+crossingAngle), 0, 0)); // absolute transformations for the final placement in the world (angles always equal zero and 180 deg) Transform3D placementTransformer(RotationY(rotateAngle), RotateY( Position(0, 0, zPosition) , rotateAngle) ); Transform3D placementTransmirror(RotationY(mirrorAngle), RotateY( Position(0, 0, zPosition) , mirrorAngle) ); // solid for the tube (including vacuum and wall): a solid cone ConeSegment tubeSolid( zHalf, 0, rOuterStart, 0, rOuterEnd, phi1, phi2); // tube consists of vacuum (will later have two different daughters) Volume tubeLog0( volName + "_0", tubeSolid, coreMaterial ); Volume tubeLog1( volName + "_1", tubeSolid, coreMaterial ); // placement of the tube in the world, both at +z and -z envelope.placeVolume( tubeLog0, placementTransformer ); envelope.placeVolume( tubeLog1, placementTransmirror ); // the wall solid and placeholders for possible SubtractionSolids ConeSegment wholeSolid( zHalf, 0, rOuterStart, 0, rOuterEnd, phi1, phi2); Solid tmpSolid0, tmpSolid1, wallSolid0, wallSolid1; // the punched subtraction solids can be asymmetric and therefore have to be created twice: // one time in the "right" way, another time in the "reverse" way, because the "mirroring" // rotation around the y-axis will not only exchange +z and -z, but also +x and -x if ( rUpstreamPunch > 1e-6 ) { // do we need a hole on the upstream branch? Tube upstreamPunch( 0, rUpstreamPunch, 5 * zHalf, phi1, phi2); // a bit longer tmpSolid0 = SubtractionSolid( wholeSolid, upstreamPunch, upstreamTransformer); tmpSolid1 = SubtractionSolid( wholeSolid, upstreamPunch, dnstreamTransformer); // [sic] } else { // dont't do anything, just pass on the unmodified shape tmpSolid0 = wholeSolid; tmpSolid1 = wholeSolid; } if (rDnstreamPunch > 1e-6 ) { // do we need a hole on the downstream branch? Tube dnstreamPunch( 0, rDnstreamPunch, 5 * zHalf, phi1, phi2); // a bit longer wallSolid0 = SubtractionSolid( tmpSolid0, dnstreamPunch, dnstreamTransformer); wallSolid1 = SubtractionSolid( tmpSolid1, dnstreamPunch, upstreamTransformer); // [sic] } else { // dont't do anything, just pass on the unmodified shape wallSolid0 = tmpSolid0; wallSolid1 = tmpSolid1; } // the wall consists of the material given in the XML Volume wallLog0( volName + "_wall_0", wallSolid0, wallMaterial ); Volume wallLog1( volName + "_wall_1", wallSolid1, wallMaterial ); wallLog0.setVisAttributes(theDetector, "TubeVis"); wallLog1.setVisAttributes(theDetector, "TubeVis"); tubeLog0.setVisAttributes(theDetector, "VacVis"); tubeLog1.setVisAttributes(theDetector, "VacVis"); // placement as a daughter volumes of the tube tubeLog0.placeVolume( wallLog0, Position() ); tubeLog1.placeVolume( wallLog1, Position() ); break; } case ODH::kPunchedUpstream: case ODH::kPunchedDnstream: { // a volume on the upstream or downstream branch with two inner holes // (implemented as a cone from which another tube is punched out) const double rCenterPunch = (crossType == ODH::kPunchedUpstream) ? (rInnerStart) : (rInnerEnd); // just alias names denoting what is meant here const double rOffsetPunch = (crossType == ODH::kPunchedDnstream) ? (rInnerStart) : (rInnerEnd); // (the database entries are "abused" in this case) // relative transformations for the composition of the SubtractionVolumes Transform3D punchTransformer(RotationY(-2 * rotateAngle), Position(zPosition * tan(-2 * rotateAngle), 0, 0)); Transform3D punchTransmirror(RotationY(+2 * rotateAngle), Position(zPosition * tan(+2 * rotateAngle), 0, 0)); // absolute transformations for the final placement in the world Transform3D placementTransformer(RotationY(rotateAngle), RotateY( Position(0, 0, zPosition) , rotateAngle) ); Transform3D placementTransmirror(RotationY(mirrorAngle), RotateY( Position(0, 0, zPosition) , mirrorAngle) ); // solid for the tube (including vacuum and wall): a solid cone ConeSegment tubeSolid( zHalf, 0, rOuterStart, 0, rOuterEnd, phi1, phi2); // tube consists of vacuum (will later have two different daughters) Volume tubeLog0( volName + "_0", tubeSolid, coreMaterial ); Volume tubeLog1( volName + "_1", tubeSolid, coreMaterial ); // placement of the tube in the world, both at +z and -z envelope.placeVolume( tubeLog0, placementTransformer ); envelope.placeVolume( tubeLog1, placementTransmirror ); // the wall solid and the piece (only a tube, for the moment) which will be punched out ConeSegment wholeSolid( zHalf, rCenterPunch , rOuterStart, rCenterPunch, rOuterEnd, phi1, phi2); Tube punchSolid( 0, rOffsetPunch, 5 * zHalf, phi1, phi2); // a bit longer // the punched subtraction solids can be asymmetric and therefore have to be created twice: // one time in the "right" way, another time in the "reverse" way, because the "mirroring" // rotation around the y-axis will not only exchange +z and -z, but also +x and -x SubtractionSolid wallSolid0( wholeSolid, punchSolid, punchTransformer); SubtractionSolid wallSolid1( wholeSolid, punchSolid, punchTransmirror); // the wall consists of the material given in the database Volume wallLog0( volName + "_wall_0", wallSolid0, wallMaterial ); Volume wallLog1( volName + "_wall_1", wallSolid1, wallMaterial ); wallLog0.setVisAttributes(theDetector, "TubeVis"); wallLog1.setVisAttributes(theDetector, "TubeVis"); tubeLog0.setVisAttributes(theDetector, "VacVis"); tubeLog1.setVisAttributes(theDetector, "VacVis"); // placement as a daughter volumes of the tube tubeLog0.placeVolume( wallLog0 , Position() ); tubeLog1.placeVolume( wallLog1 , Position() ); break; } case ODH::kUpstreamClippedFront: case ODH::kDnstreamClippedFront: case ODH::kUpstreamSlicedFront: case ODH::kDnstreamSlicedFront: { // a volume on the upstream or donwstream branch, but with the front face parallel to the xy-plane // or to a piece tilted in the other direction ("sliced" like a salami with 2 * rotateAngle) // (implemented as a slightly longer cone from which the end is clipped off) // the volume which will be used for clipping: a solid tube const double clipSize = rOuterStart; // the right order of magnitude for the clipping volume (alias name) Tube clipSolid( 0, 2 * clipSize, clipSize, phi1, phi2); // should be large enough // relative transformations for the composition of the SubtractionVolumes const double clipAngle = (crossType == ODH::kUpstreamClippedFront || crossType == ODH::kDnstreamClippedFront) ? (rotateAngle) : (2 * rotateAngle); const double clipShift = (zStart - clipSize) / cos(clipAngle) - (zPosition - clipSize / 2); // question: why is this correct? Transform3D clipTransformer(RotationY(-clipAngle), Position(0, 0, clipShift)); Transform3D clipTransmirror(RotationY(+clipAngle), Position(0, 0, clipShift)); // absolute transformations for the final placement in the world Transform3D placementTransformer(RotationY(rotateAngle), RotateY( Position(0, 0, zPosition - clipSize / 2) , rotateAngle) ); Transform3D placementTransmirror(RotationY(mirrorAngle), RotateY( Position(0, 0, zPosition - clipSize / 2) , mirrorAngle) ); // solid for the tube (including vacuum and wall): a solid cone ConeSegment wholeSolid( zHalf + clipSize / 2, 0, rOuterStart, 0, rOuterEnd, phi1, phi2); // a bit longer // clip away the protruding end SubtractionSolid tubeSolid0( wholeSolid, clipSolid, clipTransformer); SubtractionSolid tubeSolid1( wholeSolid, clipSolid, clipTransmirror); // tube consists of vacuum (will later have two different daughters) Volume tubeLog0( volName + "_0", tubeSolid0, coreMaterial ); Volume tubeLog1( volName + "_1", tubeSolid1, coreMaterial ); // placement of the tube in the world, both at +z and -z envelope.placeVolume( tubeLog0, placementTransformer ); envelope.placeVolume( tubeLog1, placementTransmirror ); if (rInnerStart != rOuterStart || rInnerEnd != rOuterEnd) { // the wall solid: a tubular cone ConeSegment wallWholeSolid( zHalf + clipSize / 2, rInnerStart, rOuterStart, rInnerEnd, rOuterEnd, phi1, phi2); // a bit longer // clip away the protruding end SubtractionSolid wallSolid0( wallWholeSolid, clipSolid, clipTransformer); SubtractionSolid wallSolid1( wallWholeSolid, clipSolid, clipTransmirror); // the wall consists of the material given in the database Volume wallLog0( volName + "_wall_0", wallSolid0, wallMaterial ); Volume wallLog1( volName + "_wall_1", wallSolid1, wallMaterial ); wallLog0.setVisAttributes(theDetector, "TubeVis"); wallLog1.setVisAttributes(theDetector, "TubeVis"); tubeLog0.setVisAttributes(theDetector, "VacVis"); tubeLog1.setVisAttributes(theDetector, "VacVis"); // placement as a daughter volumes of the tube tubeLog0.placeVolume( wallLog0, Position() ); tubeLog1.placeVolume( wallLog1, Position() ); } } break; case ODH::kUpstreamClippedRear: case ODH::kDnstreamClippedRear: case ODH::kUpstreamSlicedRear: case ODH::kDnstreamSlicedRear: { // a volume on the upstream or donwstream branch, but with the rear face parallel to the xy-plane // or to a piece tilted in the other direction ("sliced" like a salami with 2 * rotateAngle) // (implemented as a slightly longer cone from which the end is clipped off) // the volume which will be used for clipping: a solid tube const double clipSize = rOuterEnd; // the right order of magnitude for the clipping volume (alias name) Tube clipSolid( 0, 2 * clipSize, clipSize, phi1, phi2); // should be large enough // relative transformations for the composition of the SubtractionVolumes const double clipAngle = (crossType == ODH::kUpstreamClippedRear || crossType == ODH::kDnstreamClippedRear) ? (rotateAngle) : (2 * rotateAngle); const double clipShift = (zEnd + clipSize) / cos(clipAngle) - (zPosition + clipSize / 2); // question: why is this correct? Transform3D clipTransformer(RotationY(-clipAngle), Position(0, 0, clipShift)); Transform3D clipTransmirror(RotationY(+clipAngle), Position(0, 0, clipShift)); // absolute transformations for the final placement in the world Transform3D placementTransformer(RotationY(rotateAngle), RotateY( Position(0, 0, zPosition + clipSize / 2) , rotateAngle) ); Transform3D placementTransmirror(RotationY(mirrorAngle), RotateY( Position(0, 0, zPosition + clipSize / 2) , mirrorAngle) ); // solid for the tube (including vacuum and wall): a solid cone ConeSegment wholeSolid( 0, rOuterStart, 0, rOuterEnd, zHalf + clipSize / 2, phi1, phi2); // a bit longer // clip away the protruding end SubtractionSolid tubeSolid0( wholeSolid, clipSolid, clipTransformer); SubtractionSolid tubeSolid1( wholeSolid, clipSolid, clipTransmirror); // tube consists of vacuum (will later have two different daughters) Volume tubeLog0( volName + "_0", tubeSolid0, coreMaterial ); Volume tubeLog1( volName + "_1", tubeSolid1, coreMaterial ); // placement of the tube in the world, both at +z and -z envelope.placeVolume( tubeLog0, placementTransformer ); envelope.placeVolume( tubeLog1, placementTransmirror ); if (rInnerStart != rOuterStart || rInnerEnd != rOuterEnd) { // the wall solid: a tubular cone ConeSegment wallWholeSolid( rInnerStart, rOuterStart, rInnerEnd, rOuterEnd, zHalf + clipSize / 2, phi1, phi2); // a bit longer // clip away the protruding end SubtractionSolid wallSolid0( wallWholeSolid, clipSolid, clipTransformer); SubtractionSolid wallSolid1( wallWholeSolid, clipSolid, clipTransmirror); // the wall consists of the material given in the database Volume wallLog0( volName + "_wall_0", wallSolid0, wallMaterial ); Volume wallLog1( volName + "_wall_1", wallSolid1, wallMaterial ); wallLog0.setVisAttributes(theDetector, "TubeVis"); wallLog1.setVisAttributes(theDetector, "TubeVis"); tubeLog0.setVisAttributes(theDetector, "VacVis"); tubeLog1.setVisAttributes(theDetector, "VacVis"); // placement as a daughter volumes of the tube tubeLog0.placeVolume( wallLog0, Transform3D() ); tubeLog1.placeVolume( wallLog1, Transform3D() ); } break; } case ODH::kUpstreamClippedBoth: case ODH::kDnstreamClippedBoth: case ODH::kUpstreamSlicedBoth: case ODH::kDnstreamSlicedBoth: { // a volume on the upstream or donwstream branch, but with both faces parallel to the xy-plane // or to a piece tilted in the other direction ("sliced" like a salami with 2 * rotateAngle) // (implemented as a slightly longer cone from which the end is clipped off) // the volume which will be used for clipping: a solid tube const double clipSize = rOuterEnd; // the right order of magnitude for the clipping volume (alias name) Tube clipSolid( 0, 2 * clipSize, clipSize, phi1, phi2); // should be large enough // relative transformations for the composition of the SubtractionVolumes const double clipAngle = (crossType == ODH::kUpstreamClippedBoth || crossType == ODH::kDnstreamClippedBoth) ? (rotateAngle) : (2 * rotateAngle); const double clipShiftFrnt = (zStart - clipSize) / cos(clipAngle) - zPosition; const double clipShiftRear = (zEnd + clipSize) / cos(clipAngle) - zPosition; Transform3D clipTransformerFrnt(RotationY(-clipAngle), Position(0, 0, clipShiftFrnt)); Transform3D clipTransformerRear(RotationY(-clipAngle), Position(0, 0, clipShiftRear)); Transform3D clipTransmirrorFrnt(RotationY(+clipAngle), Position(0, 0, clipShiftFrnt)); Transform3D clipTransmirrorRear(RotationY(+clipAngle), Position(0, 0, clipShiftRear)); // absolute transformations for the final placement in the world Transform3D placementTransformer(RotationY(rotateAngle), RotateY( Position(0, 0, zPosition) , rotateAngle) ); Transform3D placementTransmirror(RotationY(mirrorAngle), RotateY( Position(0, 0, zPosition) , mirrorAngle) ); // solid for the tube (including vacuum and wall): a solid cone ConeSegment wholeSolid( 0, rOuterStart, 0, rOuterEnd, zHalf + clipSize, phi1, phi2); // a bit longer // clip away the protruding ends SubtractionSolid tmpSolid0 ( wholeSolid, clipSolid, clipTransformerFrnt); SubtractionSolid tmpSolid1 ( wholeSolid, clipSolid, clipTransmirrorFrnt); SubtractionSolid tubeSolid0( tmpSolid0, clipSolid, clipTransformerRear); SubtractionSolid tubeSolid1( tmpSolid1, clipSolid, clipTransmirrorRear); // tube consists of vacuum (will later have two different daughters) Volume tubeLog0( volName + "_0", tubeSolid0, coreMaterial ); Volume tubeLog1( volName + "_1", tubeSolid1, coreMaterial ); // placement of the tube in the world, both at +z and -z envelope.placeVolume( tubeLog0, placementTransformer ); envelope.placeVolume( tubeLog1, placementTransmirror ); if (rInnerStart != rOuterStart || rInnerEnd != rOuterEnd) { // the wall solid: a tubular cone ConeSegment wallWholeSolid( rInnerStart, rOuterStart, rInnerEnd, rOuterEnd, zHalf + clipSize, phi1, phi2); // a bit longer // clip away the protruding ends SubtractionSolid wallTmpSolid0( wallWholeSolid, clipSolid, clipTransformerFrnt); SubtractionSolid wallTmpSolid1( wallWholeSolid, clipSolid, clipTransmirrorFrnt); SubtractionSolid wallSolid0 ( wallTmpSolid0, clipSolid, clipTransformerRear); SubtractionSolid wallSolid1 ( wallTmpSolid1, clipSolid, clipTransmirrorRear); // the wall consists of the material given in the database Volume wallLog0(volName + "_wall_0", wallSolid0, wallMaterial ); Volume wallLog1(volName + "_wall_1", wallSolid1, wallMaterial ); wallLog0.setVisAttributes(theDetector, "TubeVis"); wallLog1.setVisAttributes(theDetector, "TubeVis"); tubeLog0.setVisAttributes(theDetector, "VacVis"); tubeLog1.setVisAttributes(theDetector, "VacVis"); // placement as a daughter volumes of the tube tubeLog0.placeVolume( wallLog0, Transform3D() ); tubeLog1.placeVolume( wallLog1, Transform3D() ); } break; } default: { throw std::runtime_error( " Beampipe_o1_v01_geo.cpp : fatal failure !! ?? " ) ; // return false; // fatal failure } }//end switch }//for all xmlSections //###################################################################################################################################################################### // add a surface just inside the beampipe for tracking: Vector3D oIPCyl( (min_radius-1.e-3) , 0. , 0. ) ; SimpleCylinder ipCylSurf( envelope , SurfaceType( SurfaceType::Helper ) , 1.e-5 , 1e-5 , oIPCyl ) ; // the length does not really matter here as long as it is long enough for all tracks ... ipCylSurf->setHalfLength( 100*dd4hep::cm ) ; volSurfaceList( tube )->push_back( ipCylSurf ) ; tube.addExtension< ConicalSupportData >( beampipeData ) ; //-------------------------------------- tube.setVisAttributes( theDetector, xmlBeampipe.visStr(), envelope ); // // tube.setPlacement(pv); return tube; }
static Ref_t create_detector(Detector& theDetector, xml_h e, SensitiveDetector sens) { xml_det_t x_det = e; int det_id = x_det.id(); string det_name = x_det.nameStr(); DetElement sdet (det_name,det_id); // --- create an envelope volume and position it into the world --------------------- Volume envelope = dd4hep::xml::createPlacedEnvelope( theDetector, e , sdet ) ; dd4hep::xml::setDetectorTypeFlag( e, sdet ) ; if( theDetector.buildType() == BUILD_ENVELOPE ) return sdet ; //----------------------------------------------------------------------------------- xml_dim_t dim = x_det.dimensions(); Material air = theDetector.air(); int nsides_inner = dim.nsides_inner(); int nsides_outer = dim.nsides_outer(); double rmin = dim.rmin(); double rmax = dim.rmax(); /// FIXME: IS THIS RIGHT? double zmin = dim.zmin(); double rcutout = dim.hasAttr(_U(rmin2)) ? dim.rmin2() : 0.; double zcutout = dim.hasAttr(_U(z2)) ? dim.z2() : 0.; Layering layering(x_det); double totalThickness = layering.totalThickness(); Readout readout = sens.readout(); Segmentation seg = readout.segmentation(); std::vector<double> cellSizeVector = seg.segmentation()->cellDimensions(0); //Assume uniform cell sizes, provide dummy cellID double cell_sizeX = cellSizeVector[0]; double cell_sizeY = cellSizeVector[1]; PolyhedraRegular polyVolume(nsides_outer,rmin,rmax,totalThickness); Volume endcapVol("endcap",polyVolume,air); if(zcutout >0. || rcutout > 0.){ PolyhedraRegular cutoutPolyVolume(nsides_inner,0,rmin+rcutout,zcutout); Position cutoutPos(0,0,(zcutout-totalThickness)/2.0); std::cout<<"Cutout z width will be "<<zcutout<<std::endl; endcapVol=Volume("endcap",SubtractionSolid(polyVolume,cutoutPolyVolume,cutoutPos),air); } DetElement endcapA(sdet,"endcap",det_id); Ref_t(endcapA)->SetName((det_name+"_A").c_str()); int layer_num = 0; int layerType = 0; double layerZ = -totalThickness/2; //Create caloData object to extend driver with data required for reconstruction LayeredCalorimeterData* caloData = new LayeredCalorimeterData ; caloData->layoutType = LayeredCalorimeterData::EndcapLayout ; caloData->inner_symmetry = nsides_inner; caloData->outer_symmetry = nsides_outer; /** NOTE: phi0=0 means lower face flat parallel to experimental floor * This is achieved by rotating the modules with respect to the envelope * which is assumed to be a Polyhedron and has its axes rotated with respect * to the world by 180/nsides. In any other case (e.g. if you want to have * a tip of the calorimeter touching the ground) this value needs to be computed */ caloData->inner_phi0 = 0.; caloData->outer_phi0 = 0.; caloData->gap0 = 0.; //FIXME caloData->gap1 = 0.; //FIXME caloData->gap2 = 0.; //FIXME /// extent of the calorimeter in the r-z-plane [ rmin, rmax, zmin, zmax ] in mm. caloData->extent[0] = rmin ; caloData->extent[1] = rmax ; ///FIXME: CHECK WHAT IS NEEDED (EXSCRIBED?) caloData->extent[2] = zmin ; caloData->extent[3] = zmin + totalThickness; endcapVol.setAttributes(theDetector,x_det.regionStr(),x_det.limitsStr(),x_det.visStr()); for(xml_coll_t c(x_det,_U(layer)); c; ++c) { xml_comp_t x_layer = c; double layer_thick = layering.layer(layer_num)->thickness(); string layer_type_name = _toString(layerType,"layerType%d"); int layer_repeat = x_layer.repeat(); double layer_rcutout = x_layer.hasAttr(_U(gap)) ? x_layer.gap() : 0; std::cout<<"Number of layers in group "<<layerType<<" : "<<layer_repeat<<std::endl; Volume layer_vol(layer_type_name,PolyhedraRegular(nsides_outer,rmin+layer_rcutout,rmax,layer_thick),air); int slice_num = 0; double sliceZ = -layer_thick/2; //Create a caloLayer struct for thiss layer type to store copies of in the parent struct LayeredCalorimeterData::Layer caloLayer ; caloLayer.cellSize0 = cell_sizeX; caloLayer.cellSize1 = cell_sizeY; double nRadiationLengths=0.; double nInteractionLengths=0.; double thickness_sum=0; for(xml_coll_t s(x_layer,_U(slice)); s; ++s) { xml_comp_t x_slice = s; string slice_name = _toString(slice_num,"slice%d"); double slice_thickness = x_slice.thickness(); Material slice_material = theDetector.material(x_slice.materialStr()); Volume slice_vol(slice_name,PolyhedraRegular(nsides_outer,rmin+layer_rcutout,rmax,slice_thickness),slice_material); slice_vol.setVisAttributes(theDetector.visAttributes(x_slice.visStr())); sliceZ += slice_thickness/2; layer_vol.placeVolume(slice_vol,Position(0,0,sliceZ)); nRadiationLengths += slice_thickness/(2.*slice_material.radLength()); nInteractionLengths += slice_thickness/(2.*slice_material.intLength()); thickness_sum += slice_thickness/2; if ( x_slice.isSensitive() ) { sens.setType("calorimeter"); slice_vol.setSensitiveDetector(sens); #if DD4HEP_VERSION_GE( 0, 15 ) //Store "inner" quantities caloLayer.inner_nRadiationLengths = nRadiationLengths; caloLayer.inner_nInteractionLengths = nInteractionLengths; caloLayer.inner_thickness = thickness_sum; //Store scintillator thickness caloLayer.sensitive_thickness = slice_thickness; #endif //Reset counters to measure "outside" quantitites nRadiationLengths=0.; nInteractionLengths=0.; thickness_sum = 0.; } nRadiationLengths += slice_thickness/(2.*slice_material.radLength()); nInteractionLengths += slice_thickness/(2.*slice_material.intLength()); thickness_sum += slice_thickness/2; sliceZ += slice_thickness/2; slice_num++; } #if DD4HEP_VERSION_GE( 0, 15 ) //Store "outer" quantities caloLayer.outer_nRadiationLengths = nRadiationLengths; caloLayer.outer_nInteractionLengths = nInteractionLengths; caloLayer.outer_thickness = thickness_sum; #endif layer_vol.setVisAttributes(theDetector.visAttributes(x_layer.visStr())); if ( layer_repeat <= 0 ) throw std::runtime_error(x_det.nameStr()+"> Invalid repeat value"); for(int j=0; j<layer_repeat; ++j) { string phys_lay = _toString(layer_num,"layer%d"); //The rest of the data is constant; only the distance needs to be updated //Store the position up to the inner face of the layer caloLayer.distance = zmin + totalThickness/2 + layerZ; //Push back a copy to the caloData structure caloData->layers.push_back( caloLayer ); layerZ += layer_thick/2; DetElement layer_elt(endcapA, phys_lay, layer_num); PlacedVolume pv = endcapVol.placeVolume(layer_vol,Position(0,0,layerZ)); pv.addPhysVolID("layer", layer_num); layer_elt.setPlacement(pv); layerZ += layer_thick/2; ++layer_num; } ++layerType; } double z_pos = zmin+totalThickness/2; PlacedVolume pv; // Reflect it. DetElement endcapB = endcapA.clone(det_name+"_B",x_det.id()); //Removed rotations to align with envelope //NOTE: If the envelope is not a polyhedron (eg. if you use a tube) //you may need to rotate so the axes match pv = envelope.placeVolume(endcapVol,Transform3D(RotationZYX(0,0,0), Position(0,0,z_pos))); pv.addPhysVolID("side", 1); endcapA.setPlacement(pv); //Removed rotations pv = envelope.placeVolume(endcapVol,Transform3D(RotationZYX(0,M_PI,0), Position(0,0,-z_pos))); pv.addPhysVolID("side", 2); endcapB.setPlacement(pv); sdet.add(endcapB); sdet.addExtension< LayeredCalorimeterData >( caloData ) ; return sdet; }
static Ref_t create_element(Detector& theDetector, xml_h xmlHandle, SensitiveDetector /*sens*/) { //------------------------------------------ // See comments starting with '//**' for // hints on porting issues //------------------------------------------ std::cout << "This is the Mask:" << std::endl; // Access to the XML File xml_det_t xmlMask = xmlHandle; const std::string name = xmlMask.nameStr(); //-------------------------------- Assembly envelope(name + "_assembly"); //-------------------------------- DetElement tube(name, xmlMask.id()); // const double phi1 = 0 ; // const double phi2 = 360.0*dd4hep::degree; // Parameters we have to know about dd4hep::xml::Component xmlParameter = xmlMask.child(_Unicode(parameter)); const double crossingAngle = xmlParameter.attr<double>(_Unicode(crossingangle)) * 0.5; // only half the angle for (xml_coll_t c(xmlMask, Unicode("section")); c; ++c) { xml_comp_t xmlSection(c); ODH::ECrossType crossType = ODH::getCrossType(xmlSection.attr<std::string>(_Unicode(type))); const double zStart = xmlSection.attr<double>(_Unicode(start)); const double zEnd = xmlSection.attr<double>(_Unicode(end)); const double rInnerStart = xmlSection.attr<double>(_Unicode(rMin1)); const double rInnerEnd = xmlSection.attr<double>(_Unicode(rMin2)); const double rOuterStart = xmlSection.attr<double>(_Unicode(rMax1)); const double rOuterEnd = xmlSection.attr<double>(_Unicode(rMax2)); const double phi1 = xmlSection.attr<double>(_Unicode(Phi1)); const double phi2 = xmlSection.attr<double>(_Unicode(Phi2)); const double thickness = rOuterStart - rInnerStart; Material sectionMat = theDetector.material(xmlSection.materialStr()); const std::string volName = "tube_" + xmlSection.nameStr(); std::cout << std::setw(8) << zStart << std::setw(8) << zEnd << std::setw(8) << rInnerStart << std::setw(8) << rInnerEnd << std::setw(8) << rOuterStart << std::setw(8) << rOuterEnd << std::setw(8) << thickness << std::setw(8) << crossType << std::setw(8) << phi1 << std::setw(8) << phi2 << std::setw(15) << volName << std::setw(15) << sectionMat.name() << std::endl; // things which can be calculated immediately const double zHalf = fabs(zEnd - zStart) * 0.5; // half z length of the cone const double zPosition = fabs(zEnd + zStart) * 0.5; // middle z position Material material = sectionMat; // this could mess up your geometry, so better check it if (not ODH::checkForSensibleGeometry(crossingAngle, crossType)) { throw std::runtime_error(" Mask_o1_v01_noRot_geo.cpp : checkForSensibleGeometry() failed "); } const double rotateAngle = getCurrentAngle(crossingAngle, crossType); // for the placement at +z (better make it const now) const double mirrorAngle = M_PI - rotateAngle; // for the "mirrored" placement at -z // the "mirroring" in fact is done by a rotation of (almost) 180 degrees around the y-axis switch (crossType) { case ODH::kCenter: case ODH::kUpstream: case ODH::kDnstream: { // a volume on the z-axis, on the upstream branch, or on the downstream branch // absolute transformations for the placement in the world, rotate over X Transform3D transformer(RotationX(rotateAngle), RotateX(Position(0, 0, zPosition), rotateAngle)); Transform3D transmirror(RotationX(mirrorAngle), RotateX(Position(0, 0, zPosition), mirrorAngle)); // solid for the tube (including vacuum and wall): a solid cone ConeSegment tubeSolid(zHalf, rInnerStart, rOuterStart, rInnerEnd, rOuterEnd, phi1, phi2); // tube consists of vacuum Volume tubeLog(volName, tubeSolid, material); tubeLog.setVisAttributes(theDetector, xmlMask.visStr()); // placement of the tube in the world, both at +z and -z envelope.placeVolume(tubeLog, transformer); envelope.placeVolume(tubeLog, transmirror); } break; case ODH::kPunchedCenter: { // a cone with one or two inner holes (two tubes are punched out) const double rUpstreamPunch = rInnerStart; // just alias names denoting what is meant here const double rDnstreamPunch = rInnerEnd; // (the database entries are "abused" in this case) // relative transformations for the composition of the SubtractionVolumes Transform3D upstreamTransformer(RotationY(-crossingAngle), Position(zPosition * tan(-crossingAngle), 0, 0)); Transform3D dnstreamTransformer(RotationY(+crossingAngle), Position(zPosition * tan(+crossingAngle), 0, 0)); // absolute transformations for the final placement in the world (angles always equal zero and 180 deg) Transform3D placementTransformer(RotationY(rotateAngle), RotateY(Position(0, 0, zPosition), rotateAngle)); Transform3D placementTransmirror(RotationY(mirrorAngle), RotateY(Position(0, 0, zPosition), mirrorAngle)); // the main solid and the two pieces (only tubes, for the moment) which will be punched out ConeSegment wholeSolid(zHalf, 0, rOuterStart, 0, rOuterEnd, phi1, phi2); Solid tmpSolid0, tmpSolid1, finalSolid0, finalSolid1; // the punched subtraction solids can be asymmetric and therefore have to be created twice: // one time in the "right" way, another time in the "reverse" way, because the "mirroring" // rotation around the y-axis will not only exchange +z and -z, but also +x and -x if (rUpstreamPunch > 1e-6) { // do we need a hole on the upstream branch? Tube upstreamPunch(0, rUpstreamPunch, 5 * zHalf, phi1, phi2); // a bit longer tmpSolid0 = SubtractionSolid(wholeSolid, upstreamPunch, upstreamTransformer); tmpSolid1 = SubtractionSolid(wholeSolid, upstreamPunch, dnstreamTransformer); // [sic] } else { // dont't do anything, just pass on the unmodified shape tmpSolid0 = wholeSolid; tmpSolid1 = wholeSolid; } if (rDnstreamPunch > 1e-6) { // do we need a hole on the downstream branch? Tube dnstreamPunch(0, rDnstreamPunch, 5 * zHalf, phi1, phi2); // a bit longer finalSolid0 = SubtractionSolid(tmpSolid0, dnstreamPunch, dnstreamTransformer); finalSolid1 = SubtractionSolid(tmpSolid1, dnstreamPunch, upstreamTransformer); // [sic] } else { // dont't do anything, just pass on the unmodified shape finalSolid0 = tmpSolid0; finalSolid1 = tmpSolid1; } // tube consists of vacuum (will later have two different daughters) Volume tubeLog0(volName + "_0", finalSolid0, material); Volume tubeLog1(volName + "_1", finalSolid1, material); tubeLog0.setVisAttributes(theDetector, xmlMask.visStr()); tubeLog1.setVisAttributes(theDetector, xmlMask.visStr()); // placement of the tube in the world, both at +z and -z envelope.placeVolume(tubeLog0, placementTransformer); envelope.placeVolume(tubeLog1, placementTransmirror); break; } case ODH::kPunchedUpstream: case ODH::kPunchedDnstream: { // a volume on the upstream or downstream branch with two inner holes // (implemented as a cone from which another tube is punched out) const double rCenterPunch = (crossType == ODH::kPunchedUpstream) ? (rInnerStart) : (rInnerEnd); // just alias names denoting what is meant here const double rOffsetPunch = (crossType == ODH::kPunchedDnstream) ? (rInnerStart) : (rInnerEnd); // (the database entries are "abused" in this case) // relative transformations for the composition of the SubtractionVolumes Transform3D punchTransformer(RotationY(-2 * rotateAngle), Position(zPosition * tan(-2 * rotateAngle), 0, 0)); Transform3D punchTransmirror(RotationY(+2 * rotateAngle), Position(zPosition * tan(+2 * rotateAngle), 0, 0)); // absolute transformations for the final placement in the world Transform3D placementTransformer(RotationY(rotateAngle), RotateY(Position(0, 0, zPosition), rotateAngle)); Transform3D placementTransmirror(RotationY(mirrorAngle), RotateY(Position(0, 0, zPosition), mirrorAngle)); // the main solid and the piece (only a tube, for the moment) which will be punched out ConeSegment wholeSolid(zHalf, rCenterPunch, rOuterStart, rCenterPunch, rOuterEnd, phi1, phi2); Tube punchSolid(0, rOffsetPunch, 5 * zHalf, phi1, phi2); // a bit longer // the punched subtraction solids can be asymmetric and therefore have to be created twice: // one time in the "right" way, another time in the "reverse" way, because the "mirroring" // rotation around the y-axis will not only exchange +z and -z, but also +x and -x SubtractionSolid finalSolid0(wholeSolid, punchSolid, punchTransformer); SubtractionSolid finalSolid1(wholeSolid, punchSolid, punchTransmirror); // tube consists of vacuum (will later have two different daughters) Volume tubeLog0(volName + "_0", finalSolid0, material); Volume tubeLog1(volName + "_1", finalSolid1, material); tubeLog0.setVisAttributes(theDetector, xmlMask.visStr()); tubeLog1.setVisAttributes(theDetector, xmlMask.visStr()); // placement of the tube in the world, both at +z and -z envelope.placeVolume(tubeLog0, placementTransformer); envelope.placeVolume(tubeLog1, placementTransmirror); break; } default: { throw std::runtime_error(" Mask_o1_v01_geo.cpp : fatal failure !! ?? "); } } // end switch } // for all xmlSections //-------------------------------------- Volume mother = theDetector.pickMotherVolume(tube); PlacedVolume pv(mother.placeVolume(envelope)); pv.addPhysVolID("system", xmlMask.id()); //.addPhysVolID("side", 0 ) ; tube.setVisAttributes(theDetector, xmlMask.visStr(), envelope); tube.setPlacement(pv); return tube; }