Gen3 geometry

[paulgessinger]

Umbrella issue for the project to unify Gen1 (layer-based) and Gen2 (initial layer-less) geometry paradigms into a Gen3 (final) geometry.

See this presentation for details.

Associated PRs:

Blueprint construction

Navigation policies

• feat(nav): Gen3 Navigation policies and factory #3760

Portal shells

• refactor: rename PortalShell connect outer to fill #3820
• feat: Gen 3 portal shells #3564

Portals

• feat: Gen3 geometry Portals #3501

Portal links

• feat(geo): Gen3 portal links #3531
• feat: Delayed Grid construction for Portals #3718

Preparation

• refactor: Expose IMaterialDecorator::decorate to python #3819
• feat(geo): Add Gen3 hierarchy search to lowestTrackingVolume #3818
• refactor: Python binding bits and pieces #3717
• fix(geo): CylVolStack reuses gaps if exist #3716
• fix: CylVolStack resizing issue #3715
• refactor(geo): Teach ProtoLayer to respect local coordinate system #3697
• feat(util): Add builder class for "chain" delegates #3696
• refactor(geo): Add portals + surfaces to closeGeometry and visitSurfaces #3678
• feat(geo): TrackingVolume gets surface storage #3675
• feat(geo): TrackingVolume gets portal storage #3673
• feat(geo): Surface::isOnSurface gets tolerance parameter #3544
• feat(geo): Add name setter and move constructor to TrackingVolume #3542
• feat(geometry): RegularSurface gets direction-less isOnSurface #3500
• refactor!: BinningValue becomes a strong enum #3337
• refactor(geometry): Surface merging uses custom exception #3334
• refactor!: Update TrackingVolume constructors #3250
• refactor!: Axis improvements: move from detail + CTAD #3257
• feat: CylinderVolumeStack #3065
• feat: Cylinder and Disc surface merging #3288
• refactor: TrackingVolume and Volume interface + functionality #3064
• feat: Add TransformRange helper #3060
• fix: Remove obsolete forward declaration AbstractVolume #3057
• refactor: Remove VolumeBoundsPtr typedef #3032
• refactor: Remove BVH navigation remnants (to be reimplemented) #3029
• refactor: Remove AbstractVolume #3030
• refactor: TrackingVolume and VolumeBounds mutability #3037
• refactor: Remove AbstractVolume #3053
• refactor: TrackingVolume/Volume cleanup #3031
• refactor: OrientedSurface improvements #3026

Initial strategy

class Node {
    
    virtual std::shared_ptr<Volume> build();
    
    virtual std::vector<Portal> connect(
        const std::shared_ptr<TrackingVolume>& volume);
    
};

• Stack Volumes: CylinderVolumeStack, CuboidVolumeStack
  • Associated CylinderContainerNode and CuboidContainerNode
• Volume::assignVolumeBounds() becomes virtual
  • Overridden by stacks, used to resize child volumes
• Portal fusing + Portal stitching
• Special nodes called explicitly CylinderLayer etc?
  • Could also just be functions on Node for building purposes

class CylinderContainerNode : public Node {
    ...
};

Two passes:

1. Recursively call build() on all children

   • Can build internal structure as configured
   • Can attach navigation delegate as configured
   • Returns a representing volume that can be a straight TrackingVolume or a composite volume like CylinderVolumeStack
   • Resizing CylinderVolumeStack resizes it's components, can create gaps on the outside if configured
   • Container nodes synchronize the representing volumes they receive, which propagates down the tree

2. Recursively call connect() with the current parent volume (starting from the root volume) as an argument

   • Regular nodes:
     • Register their TrackingVolume with the parent for ownership
     • Create a vector of Portal indexed by the common enum
     • Register the portals with their TrackingVolume for ownership and navigation
   • Containers nodes:
     • Call connect() on their children, but pass through their own parent TrackingVolume
     • No real volume is created for containers
     • They collect the portals, perform internal portal fusing + external portal stitching, then return the stitched portals
     • No portals / volumes need to be resized at this point
     • Portals are overwritten on child volumes using PortalHandle, internal registration remains valid, only outer registrations is delegated up the tree
   • When children have completed connect(), child TrackingVolumes have been registered: can create volume-local acceleration structure for finding

3. Root node receives Volume from build() used as world volume + portal vector which are not connected outside, signaling navigation termination.

Benefits:

• No size synchronization from parent needed: parents size their children
• Containers in containers are supported, portal flattening during stitching should reduce depth

Construction API:

auto root = std::make_shared<Node>();

auto cyl = std::make_shared<CylinderContainerNode>(
    Acts::binZ,
    CylinderVolumeStack::AttachmentStrategy::Midpoint
);

cyl->addChild(makeLayerNode());
cyl->addChild(makeLayerNode());

// Wraps cyl in a material decorator Node
cyl = addMaterial(std::move(cyl), 
                  Acts::tubeOuterCover, 
                  materialProperties());

root->addChild(std::move(cyl));

auto tg = root->construct();

Simplified:

auto root = std::make_shared<Node>();
root->addCylinderContainer(Acts::binZ,
                           CylinderVolumeStack::AttachmentStrategy::Gap,
                           [](std::shared_ptr<CylinderContainerNode> cyl) {
    cyl->addChild(makeLayerNode());
    cyl->addChild(makeLayerNode());
    // Wraps cyl in a material decorator Node
    return addMaterial(std::move(cyl), 
                       Acts::tubeOuterCover, 
                       materialProperties());
});
auto tg = root->construct();

And maybe in python like this (modulo unique_ptr not being usable)

root = Node()

@root.addCylinderContainer(
    direction=acts.binZ,
    strategy=acts.CylinderVolumeStack.AttachmentStrategy.Gap
)
def cyl(cyl):
    cyl.addChild(makeLayerNode())
    cyl.addChild(makeLayerNode())
    return addMaterial(cyl, 
                       acts.tubeOuterCover, 
                       materialProperties())

tg = root.construct()

[github-actions]

This issue/PR has been automatically marked as stale because it has not had recent activity. The stale label will be removed if any interaction occurs.