#include <VolumeBuilderCore.hh>

Collaboration diagram for VolumeBuilderCore:

Public Member Functions
G4VSolid *	SolidConstructor (const G4String &name) override

VolumeBuilderCore &	operator= (const VolumeBuilderCore &other)=delete

G4VPhysicalVolume *	GetPlacement () final

DerivedPtr	MakePlacement ()

DerivedPtr	PlaceAndFork ()

G4LogicalVolume *	GetLogicalVolume () final

G4VSolid *	GetBaseSolid () final

G4VSolid *	GetFinalSolid () final

DerivedPtr	MakeLogicalVolume (const VBHelpers::G4MaterialPtrOrString &material={}, G4String name=std::string())

DerivedPtr	MakeSolid ()

DerivedPtr	SetName (const G4String &name)

DerivedPtr	AddUnion (const VolumeBuilder &other, const DLG4::VolumeBuilders::ThreeVecDimensioner &offset={0, 0, 0, VB::Length::mm}, G4RotationMatrix *rotation=nullptr)

DerivedPtr	AddSubtraction (const VolumeBuilder &other, const DLG4::VolumeBuilders::ThreeVecDimensioner &offset={0, 0, 0, VB::Length::mm}, G4RotationMatrix *rotation=nullptr)

DerivedPtr	AddIntersection (const VolumeBuilder &other, const DLG4::VolumeBuilders::ThreeVecDimensioner &offset={0, 0, 0, VB::Length::mm}, G4RotationMatrix *rotation=nullptr)

DerivedPtr	AddBoolean (const VolumeBuilder &other, bool is_subtraction=false, bool is_intersection=false, const DLG4::VolumeBuilders::ThreeVecDimensioner &offset={0, 0, 0, VB::Length::mm}, G4RotationMatrix *rotation=nullptr)

DerivedPtr	SetMaterial (const VBHelpers::G4MaterialPtrOrString &material)

DerivedPtr	SetColor (double r=0.5, double g=0.5, double b=0.5, double alpha=1.0)

DerivedPtr	SetColor (const G4Colour &color)

DerivedPtr	SetAlpha (G4double alpha)

DerivedPtr	ForceSolid (bool x=true)

DerivedPtr	SetVisibility (bool x=true)

DerivedPtr	SetLogicalVolume (G4LogicalVolume *logical_volume)

DerivedPtr	SetBooleanName (const G4String &name)

DerivedPtr	SetPhysRotation (const G4RotationMatrix &rot)

DerivedPtr	StackPhysRotation (const G4RotationMatrix &stacked_rot)

DerivedPtr	SetPhysOffset (const DLG4::VolumeBuilders::ThreeVecDimensioner &offset={0, 0, 0, VB::Length::mm})

DerivedPtr	StackPhysOffset (const DLG4::VolumeBuilders::ThreeVecDimensioner &offset={0, 0, 0, VB::Length::mm})

DerivedPtr	SetPhysTransform (const UnitlessG4Transform3D &new_transform)

DerivedPtr	StackPhysTransform (const UnitlessG4Transform3D &new_transform)

G4Transform3D	GetPhysTransform () const final

DerivedPtr	OverridePlacementName (const G4String &pName)

DerivedPtr	SetCopyNo (G4int pCopyNo)

DerivedPtr	SetSurfaceCheck (G4bool pSurfChk)

DerivedPtr	SetMother (const VolumeBuilder &mother)

DerivedPtr	SetAutoPlacementNaming (bool set)

DerivedPtr	SetAutoCopyNo (bool set)

DerivedPtr	ReflectZFinalSolid ()

DerivedPtr	ReflectZBaseSolid ()

DerivedPtr	ForkAndReset (const G4String &new_name) const

DerivedPtr	ForkForFinalSolid (const G4String &new_name)

DerivedPtr	ForkForLogicalVolume (const G4String &new_name)

DerivedPtr	ForkForPlacement (std::optional< int > copy_no=std::nullopt, const G4String &name_override="", bool parent_name_was_set=false)

DerivedPtr	CopyPlacementConfigsFrom (const VolumeBuilder &other)

DerivedPtr	CopyVolumeConfigsFrom (const VolumeBuilder &other)

DerivedPtr	SetDefaultUnit (Length unit)

Length	GetEffectiveDefaultUnit () const

DerivedPtr	AddTo (BuilderViewList &list) const

DerivedPtr	AddTo (StructureViewList &list) const

DerivedPtr	AddTo (Assembly &assembly) const

G4String	GetBuilderName () const

std::shared_ptr< T >	shared_from_this ()

std::shared_ptr< const T >	shared_from_this () const

void	set_shared_from_this_enabled (bool enabled)

Protected Member Functions
SharedPtr< IStructureBuilder >	clone_impl () const override

VolumeBuilder	ToVolumeBuilder () const override

Protected Attributes
std::atomic< bool >	is_enabled_ {true}

Friends
template<typename T >
class	VolumeBuilderBase

template<typename T >
class	StructureBuilderBase

template<typename T >
class	i_shared_ptr

class	i_shared_ptr< VolumeBuilderCore >

Assembly	VB::CreateAssembly (G4String name)

Detailed Description

A polymorphic, type-erased "view" of any specialized builder.

Use it to assign a specialized builder to a generic builder. But you don't use it directly. It has no direct public ctors or factories, but BuilderView(your_other_builder_object) constructs it as i_shared_ptr<VolumeBuilderCore> ( pointer-wrapped builder). Or pass your builder to something expecting a BuilderView, like ex: a std::vector<BuilderViewr>, aka a BuilderViewList.

See also: VolumeBuilder for inherited methods.

Definition at line 43 of file VolumeBuilderCore.hh.

Member Function Documentation

◆ AddBoolean()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr AddBoolean	(	const VolumeBuilder &	other,
		bool	is_subtraction = `false`,
		bool	is_intersection = `false`,
		const DLG4::VolumeBuilders::ThreeVecDimensioner &	offset = `{0, 0, 0, VB::Length::mm}`,
		G4RotationMatrix *	rotation = `nullptr`
	)

inherited

Add a boolean operation.

This does NOT immediately trigger a build on a passed-in builder, just pre-sets the relationship.

Parameters

other	A VolumeBuilder, G4VSolid, or anything constructable by a BuilderView
is_subtraction	true for subtraction, false for union
is_intersection	true for intersection, false for union
offset	Offset applied to solid
rotation	Applied to solid

Returns: The builder

Definition at line 221 of file VolumeBuilderBase.hpp.

                                                                                                                   {
        auto offset = ProvisionUnits(new_offset);
 
        if (other) {
            boolean_configs_->booleans.emplace_back(
                BooleanSolid{other, is_subtraction, is_intersection, offset, rotation});
        } else {
            throw std::runtime_error("Error in AddBoolean() "
                                     "for builder named: \"" + builder_configs_->name + "\"\n"
                                     " volume is invalid (null)");
        }
        return this->shared_from_this();
    }

◆ AddIntersection()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr AddIntersection	(	const VolumeBuilder &	other,
		const DLG4::VolumeBuilders::ThreeVecDimensioner &	offset = `{0, 0, 0, VB::Length::mm}`,
		G4RotationMatrix *	rotation = `nullptr`
	)

inherited

Define combination another volume with present one, This does NOT immediately trigger a build on a passed-in builder, just pre-sets the relationship.

Parameters

other	A VolumeBuilder, G4VSolid, or anything constructable by a BuilderView
offset	Offset applied to solid
rotation	Applied to solid

Returns: The builder

Definition at line 205 of file VolumeBuilderBase.hpp.

                                    {
        if (other) {
            bool is_subtraction = false;
            bool is_intersection = true;
            AddBoolean(other, is_subtraction, is_intersection, new_offset, rotation);
        } else {
            throw std::runtime_error("Error in AddBoolean() "
                                     "for builder named: \"" + builder_configs_->name + "\"\n"
                                     " volume is invalid (null)");
        }
        return this->shared_from_this();
    }

◆ AddSubtraction()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr AddSubtraction	(	const VolumeBuilder &	other,
		const DLG4::VolumeBuilders::ThreeVecDimensioner &	offset = `{0, 0, 0, VB::Length::mm}`,
		G4RotationMatrix *	rotation = `nullptr`
	)

inherited

Define combination another volume with present one, This does NOT immediately trigger a build on a passed-in builder, just pre-sets the relationship.

Parameters

other	A VolumeBuilder, G4VSolid, or anything constructable by a BuilderView
offset	Offset applied to solid
rotation	Applied to solid

Returns: The builder

Definition at line 201 of file VolumeBuilderBase.hpp.

                                    {
        if (other) {
            bool is_subtraction = true;
            bool is_intersection = false;
            AddBoolean(other, is_subtraction, is_intersection, new_offset, rotation);
        } else {
            throw std::runtime_error("Error in AddBoolean(): "
                                     "for builder named: \"" + builder_configs_->name + "\"\n"
                                     "volume is invalid (null)");
        }
        return this->shared_from_this();
    }

◆ AddTo() [1/3]

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr AddTo ( Assembly & assembly ) const

inherited

Add the builder an assembly geometrically joined manipulation.

Parameters

assembly The assembly to add to.

Returns: the builder

Definition at line 630 of file VolumeBuilderBase.hpp.

                                                {
        assembly->AddStructure(this->ToStructureView());
        auto retval = shared_mutable_this(this);
        return retval;
    }

◆ AddTo() [2/3]

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr AddTo ( BuilderViewList & list ) const

inherited

Definition at line 612 of file VolumeBuilderBase.hpp.

                                                   {
        list.emplace_back(this->ToVolumeBuilder());
        auto retval = shared_mutable_this(this);
        return retval;
    }

◆ AddTo() [3/3]

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr AddTo ( StructureViewList & list ) const

inherited

Add the builder a list for group/batch manipulations.

Parameters

list	The list to add to.

Returns: the builder

Definition at line 621 of file VolumeBuilderBase.hpp.

                                                     {
        list.emplace_back(this->ToStructureView());
        auto retval = shared_mutable_this(this);
        return retval;
    }

◆ AddUnion()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr AddUnion	(	const VolumeBuilder &	other,
		const DLG4::VolumeBuilders::ThreeVecDimensioner &	offset = `{0, 0, 0, VB::Length::mm}`,
		G4RotationMatrix *	rotation = `nullptr`
	)

inherited

Define combination another volume with present one, This does NOT immediately trigger a build on a passed-in builder, just pre-sets the relationship.

Parameters

other	A VolumeBuilder, G4VSolid, or anything constructable by a BuilderView
offset	Offset applied to solid
rotation	Applied to solid

Returns: The builder

Definition at line 197 of file VolumeBuilderBase.hpp.

                                    {
        bool is_subtraction = false;
        bool is_intersection = false;
        AddBoolean(other, is_subtraction, is_intersection, new_offset, rotation);
        return this->shared_from_this();
    }

◆ clone_impl()

SharedPtr< IStructureBuilder > clone_impl ( ) const

overrideprotectedvirtual

Reimplemented from VolumeBuilderBase< VolumeBuilderCore >.

Definition at line 60 of file VolumeBuilderCore.cc.

                                                                     {
        // have the erased base clone itself:
        auto copy = builder_configs_->istructure_ptr->clone_impl();
        // Then have it create a Builder from itself:
        auto builder_view = copy->ToVolumeBuilder();
        builder_view->StoreIStructurePtr(copy); // this is the owning copy.
        builder_view->StoreBuilderView(builder_view);
 
        //return static_cast<std::shared_ptr<ISolidBuilder>>(builder_view) ;  // and return the builder
        return builder_view; // and return the builder
    }

◆ CopyPlacementConfigsFrom()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr CopyPlacementConfigsFrom ( const VolumeBuilder & other )

inherited

This may help if reusing placement configs for a different shape.

Copies the placement configuration (rotation, translation, mother, etc.) from another builder. Does NOT copy any naming, as that would conflict. Also does NOT copy any products. Use CopyPlacement Builder for that. Names will derive from present object, or you can override with Setters as usual.

Parameters

other The builder instance to copy placement configuration from.

Returns: This builder for chaining.

Definition at line 565 of file VolumeBuilderBase.hpp.

                                                                     {
        this->placement_configs_ = other->placement_configs_;
        // receiver is responsible for unique naming/numbering.
        // we can't clobber auto-name/number incrementing from another config:
        // Does not copy the solid/boolean, just to get configs ONLY
        return this->shared_from_this();
    }

◆ CopyVolumeConfigsFrom()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr CopyVolumeConfigsFrom ( const VolumeBuilder & other )

inherited

Copies the LogicalVolume configuration (material, VisAttributes, etc.) from another builder.

This DOES NOT include copying any booleans. This is useful for setting up multiple placements with similar configurations.

Parameters

other The builder instance to copy placement configuration from.

Returns: This builder for chaining.

Definition at line 576 of file VolumeBuilderBase.hpp.

                                                                  {
        // Booleans are NOT considered as part of Volume Configs.
        // We keep our booleans.
        auto name = this->builder_configs_->name; // backup our name
        auto booleans = this->boolean_configs_->booleans;
        this->lv_configs_ = other->lv_configs_;
        //   restor name.  This is easier than keeping name separately. :P
        this->builder_configs_->name = name;
        this->boolean_configs_->booleans = booleans; // restore ours.
        return this->shared_from_this();
    }

◆ ForceSolid()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr ForceSolid ( bool x = true )

inherited

Returns: The builder

Definition at line 266 of file VolumeBuilderBase.hpp.

                                   {
        lv_configs_->force_solid = x;
        ApplyAttributes_();
        return this->shared_from_this();
    }

◆ ForkAndReset()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr ForkAndReset ( const G4String & new_name ) const

inherited

Copy a configured/unbuilt Builder, with a new name.

This is the most generic all-purpose copier, but can result in some duplication of constituent solids, etc.

Copies all configurations. You can modify and rebuild all products. Copying-Transformations are not remembered. Base implementation is in VolumeBuilder, but can be overridden for Solid-Builder specific needs.

Parameters

new_name

Returns

Definition at line 499 of file VolumeBuilderBase.hpp.

                                                             {
        NoNameCheck(new_name, "CopySolidBuilder");
        DerivedPtr copy = this->Clone();
        copy->SetName(new_name); // Set base name for derived class
        copy->SetBooleanName("");
        return copy;
    }

◆ ForkForFinalSolid()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr ForkForFinalSolid ( const G4String & new_name )

inherited

Calls MakeSolid() and copies builder with products cleared for further construction.

Configurations from ALL stages (including later) are kept.

Parameters

new_name The base name for the new builder's Geant products.

Returns: A shared pointer to the new builder instance.

Definition at line 510 of file VolumeBuilderBase.hpp.

                                                            {
        NoNameCheck(new_name, "ForkForFinalSolid");
        if (!solid_ptr_) {
            MakeSolid();
        }
        DerivedPtr copy = this->Clone();
        copy->SetName(new_name); // Set base name for derived class
        copy->SetBooleanName("");
        // all products are cleared by default, (re)build up to Solid
        copy->solid_ptr_.Link(this->solid_ptr_);
        return copy;
    }

◆ ForkForLogicalVolume()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr ForkForLogicalVolume ( const G4String & new_name )

inherited

Makes final solid (including booleans) if unbuilt and copies builder with products cleared for further construction.

Configurations from ALL stages (including later) are kept.

This one seems pretty specific, but could be useful for extending a boolean build more easily possibly

Parameters

new_name The base name for the new builder's logical and physical volumes.

Returns: A shared pointer to the new builder instance.

Definition at line 525 of file VolumeBuilderBase.hpp.

                                                               {
        NoNameCheck(new_name, "ForkForLogicalVolume");
        if (!final_solid_ptr_ && placement_configs_->is_builder) {
            [[maybe_unused]] auto discard = GetFinalSolid();
        }
        DerivedPtr copy = this->Clone();
        copy->SetName(new_name); // Set base name for derived class
        copy->SetBooleanName("");
        // all products are cleared by default, (re)build up to Solid
        if (solid_ptr_ && placement_configs_->is_builder) {
            copy->solid_ptr_.Link(this->solid_ptr_);
        }
        if (final_solid_ptr_ && placement_configs_->is_builder) {
            copy->final_solid_ptr_.Link(this->final_solid_ptr_);
        }
        return copy;
    }

◆ ForkForPlacement()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr ForkForPlacement	(	std::optional< int >	copy_no = `std::nullopt`,
		const G4String &	name_override = `""`,
		bool	parent_name_was_set = `false`
	)

inherited

Calls MakeLogicalVolume() and creates a new builder instance with a copy of all placement-related configs.

This will be called automatically by consecutive calls to MakePlacement(). All physical volume and (future?) derived products are reset to be rebuilt. Copy_no and placement name can be auto incremented (number only by default) or overridden.

The copy_no will be incremented.

Parameters

copy_no	no arguments or std::nullopt to leave as auto. Must set on every use to get manual numbering.
name_override	An optional name override for the physical volume. Leave blank to use auto controls instead.

Returns: A shared pointer to the new builder instance.

Definition at line 542 of file VolumeBuilderBase.hpp.

                                                                 {
        // really a clone of logical volume:
        if (!logicvol_ptr_ && placement_configs_->is_builder) {
            MakeLogicalVolume();
        }
        DerivedPtr copy = this->Clone();
        copy->explicit_copyno_set_ = static_cast<bool>(copy_no);
        copy->explicit_physical_copy_name_set_ = !name_override.empty() || parent_name_was_set;
        copy->placement_name_override_ = name_override;
        // register name and get provisional copy_no:
        copy->placement_configs_->copy_no = PlacementNameRegistry::IncrementNameCount(
            GetPlacementBaseName());
        //Override if copy_no was passed:
        copy->placement_configs_->copy_no = copy_no.value_or(copy->placement_configs_->copy_no);
 
        // Restore logical_volume pointer and below
        copy->solid_ptr_.Link(this->solid_ptr_);
        copy->final_solid_ptr_.Link(this->final_solid_ptr_);
        copy->logicvol_ptr_.Link(this->logicvol_ptr_);
 
        return copy;
    }

◆ GetBaseSolid()

G4VSolid * GetBaseSolid ( )

finalvirtualinherited

You probably want GetSolid() instead!!! This Gets a built Solid, BUT NOT final Boolean.

Builds default if not built yet.

Even if you aren't doing boolean now, if you add it later, this method will miss it. GetFinalSolid() is more general.

Returns: Raw visitor pointer to the solid. (DON'T DELETE IT!)

Implements IVolumeBuilder.

Definition at line 138 of file VolumeBuilderBase.hpp.

                                 {
        if (!this->solid_ptr_) {
            MakeSolid();
        }
        return solid_ptr_.get_mutable();
    }

◆ GetBuilderName()

G4String GetBuilderName ( ) const

inherited

Definition at line 639 of file VolumeBuilderBase.hpp.

                                        {
        return this->builder_configs_->name;
    }

◆ GetEffectiveDefaultUnit()

VB::Length GetEffectiveDefaultUnit ( ) const

inherited

Get the builder default unit or global if not set.

Returns: The active default unit.

Definition at line 602 of file VolumeBuilderBase.hpp.

                                                 {
        auto temp = builder_configs_.get();
        auto local = temp->default_unit;
        //        auto local = builder_configs_->default_unit;
        auto global = DLG4::Units::global_default_unit<DLG4::Units::Length>;
        G4double default_unit = local.value_or(global);
        return Length(default_unit,Length::native);
    }

◆ GetFinalSolid()

G4VSolid * GetFinalSolid ( )

finalvirtualinherited

Gets a complete final built Solid, including configured Boolean operaions if any.

Builds default if not built yet.

Returns: Raw visitor pointer to the solid. (DON'T DELETE IT!)

Implements IVolumeBuilder.

Definition at line 146 of file VolumeBuilderBase.hpp.

                                   {
        if (!final_solid_ptr_ && placement_configs_->is_builder) {
            MakeFinalSolid(std::string("")); // checks are done in there.
        }
        // should probably have a check here, although it's a bug anyway if not built now.
        return this->final_solid_ptr_;
    }

◆ GetLogicalVolume()

G4LogicalVolume * GetLogicalVolume ( )

finalvirtualinherited

Gets a built LogicalVolume, builds default if not built yet.

Returns: Raw visitor pointer to the logical volume (DON'T DELETE IT!)

Implements IVolumeBuilder.

Definition at line 126 of file VolumeBuilderBase.hpp.

                                            {
        if (!logicvol_ptr_) {
            BASE::MakeLogicalVolume();
        }
        return logicvol_ptr_.get_mutable();
    }

◆ GetPhysTransform()

G4Transform3D GetPhysTransform ( ) const

inlinefinalvirtualinherited

A helper to get the Physical Volume transform with units applied This is built from rotation and translatin if they were provided, or from a transform if it was provided, with units applied as specified.

Basically allows you to get the unit-multiplied version for use in direct Geant calls.

Returns: The Physical volume G4Transform3D with units applied.

Implements IVolumeBuilder.

Definition at line 387 of file VolumeBuilderBase.hh.

                                                     {
            return {placement_configs_->rotation, placement_configs_->translation};
        }

◆ GetPlacement()

G4VPhysicalVolume * GetPlacement ( )

finalvirtualinherited

Gets the (last) placed physical volume.

Constructs it if not built yet. Unlike MakePlacement(), this will NOT auto-trigger consecutive placments from copied builders. But you can call it again after MakePlacement() to get those.

Returns: Raw visitor pointer to physical volume. (DON'T DELETE IT).

Implements IVolumeBuilder.

Definition at line 91 of file VolumeBuilderBase.hpp.

                                          {
        if (!this->placement_) {
            BASE::MakePlacement();
        }
        return this->placement_.get_mutable();
    }

◆ MakeLogicalVolume()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr MakeLogicalVolume	(	const VBHelpers::G4MaterialPtrOrString &	material = `{}`,
		G4String	name = `std::string()`
	)

inherited

Basically never needed now.

Builds the logical volume and returns the builder. GetLogicalVolume(), or passing the builder to any consumer will trigger the build anyway.

Parameters

material	G4Material* OR a string name of a local or NIST material!
name	Optional explicit name for logical volume. Normally already derived from builder/solid name.

Returns: This builder.

Definition at line 160 of file VolumeBuilderBase.hpp.

                                                                                                 {
        ValidateForVolumeBuild(STRINGIFY(BASE) "MakeLogicalVolume");
        //if no volume was previously built, should be safe to reset material.
        if (material) {
            lv_configs_->material = material;
        }
        if (name.empty()) {
            name = this->GetLogicVolName() + "_L";
        }
        // Implicit construction through
        // ctor args..
        logicvol_ptr_.ConstructAndRawLink(final_solid_ptr_,
            lv_configs_->material,
            name);
        // non-owning link:
        logicvol_ptr_.make_persistent();
 
        ApplyAttributes_();
        return this->shared_from_this();
    }

◆ MakePlacement()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr MakePlacement ( )

inherited

Make a placed physical volume.

Retrieve it or make and retrieve with GetPlacement() Fails (throws) if already built. Make a copy first.

Returns: The builder

Definition at line 101 of file VolumeBuilderBase.hpp.

                                {
        // the copy part comes from validate below, if we're already built:
        ValidateForPVBuild(STRINGIFY(BASE) "MakePlacement");
        // 1. Get the logical volume for *this* builder
        auto *currentLogical = this->GetLogicalVolume();
        if (!(explicit_physical_copy_name_set_
              || explicit_copyno_set_
              || placement_configs_->auto_copy_name
              || placement_configs_->auto_copyno)
        ) {
            G4cout << "Warning: Placement Builder for " + builder_configs_->name +
                " copied without setting name or copy number and auto naming and numbering have been disabled \n"
                "Copy number auto-incrementing will be re-enabled \n"
                "  Use SetAutoCopyNo(true), SetAuCopyName(true), OverridePlacementName(\"name\"),  SetCopyNo(num)  \n"
                " to pass a name or number to MakePlacement()" << G4endl;
            placement_configs_->copy_no = PlacementNameRegistry::GetNameCount(
                GetPlacementBaseName());
        }
 
        // 2. Resolve the Mother Logical Volume
        G4LogicalVolume *effectiveMotherLogical = nullptr;
 
        G4String base_name = this->GetPlacementBaseName();
        G4String final_name;
        if (placement_configs_->auto_copy_name) {
            // auto naming incrementing
            final_name = base_name + "_P" +
                         std::to_string(
                             PlacementNameRegistry::GetNameCount(GetPlacementBaseName()));
        } else {
            final_name = GetPlacementBaseName() + "_P";
        }
        // unless an override was set, then take it verbatim, user's blame :):
        if (!placement_name_override_.empty()) {
            final_name = placement_name_override_;
        }
 
        if (placement_configs_->mother == nullptr || !placement_configs_->mother->
            GetLogicalVolume()) {
            // will lazay trigger mother build if needed
            G4cout << "WARNING in MakePlacement of " + final_name +
                ". No mother volume was set or constructable.\n"
                "Defaulting to world volume" << G4endl;
        }
 
        if (placement_configs_->mother) {
            effectiveMotherLogical = placement_configs_->mother->GetLogicalVolume();
        } else {
            effectiveMotherLogical = nullptr; // world placement
        }
 
        auto transform = G4Transform3D(placement_configs_->total_rotation,
            placement_configs_->total_translation);
        // 4. Create the G4PVPlacement
        // placement is <G4VPhysicalVolume> and can construct itself:
        placement_.LinkToRaw(new G4PVPlacement(
            transform, // G4Transform3D transform
            currentLogical, // pCurrentLogical
            final_name, // pName
            effectiveMotherLogical, // pMotherLogical
            false, // many option, only false allowed (unless you remember Geant3 :))
            placement_configs_->copy_no, // pCopyNo
            placement_configs_->surface_check // pSurfChk
            ));
        if (!placement_) {
            throw std::runtime_error(
                "MakeLogicalPlacement failed "
                "for builder named: \"" + builder_configs_->name + "\"\n"
                " pointer is null after calling G4PVPlacement().");
        }
        return this->shared_from_this();
    }

◆ MakeSolid()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr MakeSolid ( )

inherited

Make the G4VSolid.

Returns the builder. Use GetBaseSolid() to retrieve or make and retrieve it.

Returns: The builder

Definition at line 168 of file VolumeBuilderBase.hpp.

                            {
        G4VSolid *solid;
        G4String final_name = GetBuilderName();
        if (builder_configs_->reflect_base_solid_z) {
            solid = SolidConstructor(final_name + "_proto_solid");
            solid = new G4ReflectedSolid(final_name, solid, G4ReflectZ3D(0));
        } else {
            solid = SolidConstructor(final_name);
        }
        solid_ptr_.LinkToRaw(solid);
        return this->shared_from_this();
    }

◆ operator=()

VolumeBuilderCore & operator= ( const VolumeBuilderCore & other )

delete

◆ OverridePlacementName()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr OverridePlacementName ( const G4String & pName )

inherited

Set the placement name for the volume.

Parameters

pName Name for the placement.

Returns: This builder for chaining.

Definition at line 398 of file VolumeBuilderBase.hpp.

                                                             {
        explicit_physical_copy_name_set_ = static_cast<bool>(pName);
        this->placement_name_override_ = pName;
        return this->shared_from_this();
    }

◆ PlaceAndFork()

DerivedPtr PlaceAndFork ( )

inlineinherited

An alias for MakePlacement and ForkForPlacement Used for one or many unaltered placments in sequence, usually with auto naming and/or numbering.

Returns: The builder

Definition at line 112 of file VolumeBuilderBase.hh.

                                  {
            this->MakePlacement();
            auto clone = this->ForkForPlacement(); // default/preset options
            return clone;
        }

◆ ReflectZBaseSolid()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr ReflectZBaseSolid ( )

inherited

Configure base solid to be flipped BEFORE applying booleans.

See also: ReflectZFinalSolid() to flip entire solid with or without Booleans.

Returns: The same builder (allows chaining)

Definition at line 483 of file VolumeBuilderBase.hpp.

                                    {
        if (final_solid_ptr_) {
            throw std::runtime_error("Error VolumeBuilderBase::ReflectZBaseSolid,  \n"
                "The base solid is already built.  \n");
        }
        builder_configs_->reflect_base_solid_z = true;
        return this->shared_from_this();
    }

◆ ReflectZFinalSolid()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr ReflectZFinalSolid ( )

inherited

Configure final solid to be flipped in z.

Definition at line 473 of file VolumeBuilderBase.hpp.

                                     {
        if (final_solid_ptr_) {
            throw std::runtime_error("Error VolumeBuilderBase::ReflectZFinalSolid,  \n"
                "The final solid is already built.  \n");
        }
        boolean_configs_->reflect_z = true;
        return this->shared_from_this();
    }

◆ set_shared_from_this_enabled()

template<typename T >

void set_shared_from_this_enabled ( bool enabled )

inlineinherited

Definition at line 60 of file disableable_shared_from_this.hh.

                                                        {
            is_enabled_ = enabled;
        }

◆ SetAlpha()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr SetAlpha ( G4double alpha )

inherited

Parameters

alpha

Returns: The builder

Definition at line 259 of file VolumeBuilderBase.hpp.

                                       {
        lv_configs_->color.SetAlpha(alpha);
        ApplyAttributes_();
        return this->shared_from_this();
    }

◆ SetAutoCopyNo()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr SetAutoCopyNo ( bool set )

inherited

Enable (disable for false) auto Physical Volume numbering, on by default.

Adds a copy number to every name. By default copy numbers auto increment. Or you can set explicit names and numbers in ClonePlacement.

Parameters

set	True before setting.

Returns

Definition at line 455 of file VolumeBuilderBase.hpp.

                                              {
        placement_configs_->auto_copyno = set;
        if (set) {
            placement_configs_->auto_copy_name = false;
        }
        return this->shared_from_this();
    }

◆ SetAutoPlacementNaming()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr SetAutoPlacementNaming ( bool set )

inherited

Enable auto Physical Volume naming.

Adds a copy number to every name. By default copy numbers auto increment.
This will turn that off. Both makes no sense.
Or you can set explicit names and numbers in ClonePlacement.

Parameters

set	False before setting.

Returns

Definition at line 442 of file VolumeBuilderBase.hpp.

                                                       {
        placement_configs_->auto_copy_name = set;
        if (set) {
            placement_configs_->auto_copyno = false;
        }
        return this->shared_from_this();
    }

◆ SetBooleanName()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr SetBooleanName ( const G4String & name )

inherited

Pre-set base name for logical and physical volumes.

_L and _P will be appended, respectively.

If not set, the builder will take it from the builder name. But this is useful for unions where the starting solid name may be more specific.

Parameters

name

Definition at line 302 of file VolumeBuilderBase.hpp.

                                                     {
        this->boolean_configs_->boolean_name = name;
        return this->shared_from_this();
    }

◆ SetColor() [1/2]

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr SetColor ( const G4Colour & color )

inherited

Parameters

color

Returns: The builder

Definition at line 251 of file VolumeBuilderBase.hpp.

                                                {
        lv_configs_->color = color;
        ApplyAttributes_();
        return this->shared_from_this();
    }

◆ SetColor() [2/2]

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr SetColor	(	double	r = `0.5`,
		double	g = `0.5`,
		double	b = `0.5`,
		double	alpha = `1.0`
	)

inherited

Returns: The builder

Definition at line 243 of file VolumeBuilderBase.hpp.

                                                                                             {
        lv_configs_->color = G4Colour(r, g, b, alpha);
        ApplyAttributes_();
        return this->shared_from_this();
    }

◆ SetCopyNo()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr SetCopyNo ( G4int pCopyNo )

inherited

Set the copy number for the placement.

Parameters

pCopyNo Copy number.

Returns: This builder for chaining.

Definition at line 407 of file VolumeBuilderBase.hpp.

                                         {
        explicit_copyno_set_ = static_cast<bool>(pCopyNo);
        this->placement_configs_->copy_no = pCopyNo;
        return this->shared_from_this();
    }

◆ SetDefaultUnit()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr SetDefaultUnit ( VB::Length unit )

inherited

Set the per-Builder default unit for all later non-factory offsets.

Use DLG4::VolumeBuilders::SetGlobalDefaultUnit() to set a default for all builders, or fall back to the initial default of VB::Length::mm.

May not apply to values set before this is called.
Does not apply to factory units like CreateCenteredBoxBuilder();
But should not be set and changed. Just use it once, early.

Parameters

unit The VB::Length unit to set, ex: VB::Length::mm

Returns
The builder (allows chaining)

Definition at line 595 of file VolumeBuilderBase.hpp.

                                              {
        this->builder_configs_->default_unit = unit.Native();
        return this->shared_from_this();
    }

◆ SetLogicalVolume()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr SetLogicalVolume ( G4LogicalVolume * logical_volume )

inherited

Directly Provide a Logical Volume Instead of using the builder.

Parameters

logical_volume

Definition at line 291 of file VolumeBuilderBase.hpp.

                                                                  {
        SetLogicalVolume_impl(logical_volume);
        return this->shared_from_this();
    }

◆ SetMaterial()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr SetMaterial ( const VBHelpers::G4MaterialPtrOrString & material )

inherited

/**

Parameters

material G4Material* OR a string name of a local or NIST material!

Returns: The builder

Definition at line 236 of file VolumeBuilderBase.hpp.

                                                                            {
        lv_configs_->material = material;
        return this->shared_from_this();
    }

◆ SetMother()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr SetMother ( const VolumeBuilder & mother )

inherited

Set the mother volume with a builder, or G4VPhysicalVolume or G4VLogicalVolume through implicit conversion.

This does NOT immediately force a build the mother builder, just pre-sets the relationship.

Parameters

mother BuilderVew parameter accepts a builder or a G4VSolid through implicit ctor

Returns: This builder for chaining.

Definition at line 429 of file VolumeBuilderBase.hpp.

                                                       {
        if (!mother) {
            throw std::runtime_error("Error in VolumeBuilderBase::SetMother,"
                                     "for builder named: \"" + builder_configs_->name + "\"\n"
                                     " no valid mother physical volume provided");
            // We cannot actually fully check this yet because we allow this to be a forward association
            // The logical volume is not required to be constructable before we make a placement.
        }
        this->placement_configs_->mother = mother;
        return this->shared_from_this();
    }

◆ SetName()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr SetName ( const G4String & name )

inherited

SetName Sets name used for solid and derived product names.

Parameters

name The name

Returns: The builder

Definition at line 175 of file VolumeBuilderBase.hpp.

                                              {
        this->builder_configs_->name = name;
        return this->shared_from_this();
    }

◆ SetPhysOffset()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr SetPhysOffset ( const DLG4::VolumeBuilders::ThreeVecDimensioner & offset = {0, 0, 0, VB::Length::mm} )

inherited

Set the translation vector for placement.

Using Set, rotation applies before translation, regardless of order set, just as in G4PVPlacement() You can pass (x, y, z, unit) or use the default unit with (x, y, z).

Examples: SetPhysOffset({ 1, 2, 3, VB::cm}) // 1cm, 2cm, 3cm SetPhysOffset({1, 2, 3}) // Uses default default unit (usually mm) SetDefaultUnit(VB::cm); SetPhysOffset({1, 2, 3}) // 1cm, 2cm, 3cm // or work with raw geant values, must use CLHEP units, not VB: SetDefaultUnit(VB::native); SetPhysOffset({10*CLHEP::mm, 20*CLHEP::mm, 30*CLHEP::mm})

Parameters

offset Translation vector. See method description for details.

Returns: This builder for chaining.

Definition at line 341 of file VolumeBuilderBase.hpp.

                                                                                       {
        const auto &offset = ProvisionUnits(new_offset);
        placement_configs_->translation = offset;
        PropagateTransform();
        return this->shared_from_this();
    }

◆ SetPhysRotation()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr SetPhysRotation ( const G4RotationMatrix & rot )

inherited

Set the rotation matrix for placement.

Using Set, rotation applies before translation, regardless of order set, just as in G4PVPlacement()

Parameters

rot	Pointer to the rotation matrix.

Returns: This builder for chaining.

Definition at line 311 of file VolumeBuilderBase.hpp.

                                                             {
        G4RotationMatrix nullrot;
        this->placement_configs_->rotation = rot;
        PropagateTransform();
        return this->shared_from_this();
    }

◆ SetPhysTransform()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr SetPhysTransform ( const UnitlessG4Transform3D & new_transform )

inherited

Set the G4Transform3D for placment.

The tranformation provided is meant to be in UNITLESS values. Ie the unit is already pre-configured but not included in the values. So passing 5 means 5cm if SetDefault(VB::Length::cm) was set. Otherwise you SetDefaultUnit(VB::roaw), and pass a value that was already multipled by units. To supply different units for each G4Tranform3D separately, just call SetDefaultUnit(unit) before each call. The call will overwite/replace rotation and translation.

Parameters

new_transform Translation vector.

Returns: This builder for chaining.

Definition at line 368 of file VolumeBuilderBase.hpp.

                                                                     {
        SetPhysRotation(new_transform.getRotation()); // gets a copy on stack
        SetPhysOffset({ (G4ThreeVector)new_transform.getTranslation(), GetEffectiveDefaultUnit()});
        PropagateTransform();
        return this->shared_from_this();
    }

◆ SetSurfaceCheck()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr SetSurfaceCheck ( G4bool pSurfChk )

inherited

Set the surface check flag for the placement.

Parameters

pSurfChk Boolean flag for surface check.

Returns: This builder for chaining.

Definition at line 415 of file VolumeBuilderBase.hpp.

                                                 {
        this->placement_configs_->surface_check = pSurfChk;
        return this->shared_from_this();
    }

◆ SetVisibility()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr SetVisibility ( bool x = true )

inherited

Parameters

x

Returns: The builder

Definition at line 274 of file VolumeBuilderBase.hpp.

                                      {
        lv_configs_->is_visible = x;
        ApplyAttributes_();
        return this->shared_from_this();
    }

◆ shared_from_this() [1/2]

template<typename T >

std::shared_ptr< T > shared_from_this ( )

inlineinherited

Definition at line 44 of file disableable_shared_from_this.hh.

                                            {
            if (is_enabled_) {
                return std::enable_shared_from_this<T>::shared_from_this();
            } else {
                return nullptr;
            }
        }

◆ shared_from_this() [2/2]

template<typename T >

std::shared_ptr< const T > shared_from_this ( ) const

inlineinherited

Definition at line 52 of file disableable_shared_from_this.hh.

                                                        {
            if (is_enabled_) {
                return std::enable_shared_from_this<T>::shared_from_this();
            } else {
                return nullptr;
            }
        }

◆ SolidConstructor()

G4VSolid * SolidConstructor ( const G4String & name )

overridevirtual

polymorphic access to solid construction

Implements VolumeBuilderBase< VolumeBuilderCore >.

Definition at line 18 of file VolumeBuilderCore.cc.

                                                                      {
        if (!this->builder_configs_->istructure_ptr) {
            throw std::runtime_error(
                "Error in VolumeBuilderCore::VolumeBuilderCore::SolidConstructor(const G4String &name) \n"
                "In VolumeBuilderCore::VolumeBuilderCore::SolidConstructor(const G4String &name): No solid configuration to construct on"
                + this->builder_configs_->name);
        }
        return this->builder_configs_->istructure_ptr->SolidConstructor(name);
    }

◆ StackPhysOffset()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr StackPhysOffset ( const DLG4::VolumeBuilders::ThreeVecDimensioner & offset = {0, 0, 0, VB::Length::mm} )

inherited

Like SetPhysOffset but stacks with previous transformations in order applied.

Unlike with G4Transform multiplication, stacking is done in a way that allows mutiple objects to move together. The first transformations can set individual objects, and a uniform transformation can be applied to them all to create a rigid motion of the collection.

Parameters

offset

Returns: The builder

Definition at line 352 of file VolumeBuilderBase.hpp.

                                                                                             {
        const auto &offset = ProvisionUnits(stacked_offset);
        placement_configs_->translation += offset; // add translation
        PropagateTransform();
        return this->shared_from_this();
    }

◆ StackPhysRotation()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr StackPhysRotation ( const G4RotationMatrix & stacked_rot )

inherited

Like SetPhysRotation but stacks with previous transformations in order applied.

Unlike with G4Transform multiplication, stacking is done in a way that allows mutiple objects to move together. The first transformations can set individual objects, and a uniform transformation can be applied to them all to create a rigid motion of the collection.

Parameters

stacked_rot

Returns: The builder

Definition at line 323 of file VolumeBuilderBase.hpp.

                                                               {
        // some aliases
        const auto &old_rot = placement_configs_->rotation;
        const auto &old_trans = placement_configs_->translation;
        // sanitize input
        auto new_rot = rot * old_rot; // order matters.
        auto new_trans = rot * old_trans;
        this->placement_configs_->rotation = new_rot;
        this->placement_configs_->translation = new_trans;
        PropagateTransform();
        return this->shared_from_this();
    }

◆ StackPhysTransform()

VolumeBuilderBase< VolumeBuilderCore >::DerivedPtr StackPhysTransform ( const UnitlessG4Transform3D & new_transform )

inherited

Like SetPhysTransform but stacks with previous transformations in order applied.

Parameters

new_transform

Returns: The builder

Definition at line 375 of file VolumeBuilderBase.hpp.

                                                                       {
        //order matters when stacking.  Not when "setting"
        StackPhysRotation(new_transform.getRotation()); // gets a copy on stack
        StackPhysOffset({new_transform.getTranslation(),GetEffectiveDefaultUnit()});
        PropagateTransform();
        return this->shared_from_this();
    }

◆ ToVolumeBuilder()

VolumeBuilder ToVolumeBuilder ( ) const

inlineoverrideprotectedvirtual

Reimplemented from VolumeBuilderBase< VolumeBuilderCore >.

Definition at line 106 of file VolumeBuilderCore.hh.

                                                       {
            // we're already type erased, so just return ourselves.
            return shared_mutable_this(this);
        }

Friends And Related Symbol Documentation

◆ i_shared_ptr

template<typename T >

friend class i_shared_ptr

friend

Definition at line 51 of file VolumeBuilderCore.hh.

◆ i_shared_ptr< VolumeBuilderCore >

friend class i_shared_ptr< VolumeBuilderCore >

friend

Definition at line 54 of file VolumeBuilderCore.hh.

◆ StructureBuilderBase

template<typename T >

friend class StructureBuilderBase

friend

Definition at line 48 of file VolumeBuilderCore.hh.

◆ VB::CreateAssembly

Assembly VB::CreateAssembly ( G4String name )

friend

◆ VolumeBuilderBase

template<typename T >

friend class VolumeBuilderBase

friend

Definition at line 45 of file VolumeBuilderCore.hh.

Member Data Documentation

◆ is_enabled_

template<typename T >

std::atomic<bool> is_enabled_ {true}

protectedinherited

Definition at line 37 of file disableable_shared_from_this.hh.

37{true};

The documentation for this class was generated from the following files:

include/VolumeBuilderCore.hh
src/VolumeBuilderCore.cc

Public Member Functions

Protected Member Functions

Protected Attributes

Friends

Detailed Description

Member Function Documentation

◆ AddBoolean()

◆ AddIntersection()

◆ AddSubtraction()

◆ AddTo() [1/3]

◆ AddTo() [2/3]

◆ AddTo() [3/3]

◆ AddUnion()

◆ clone_impl()

◆ CopyPlacementConfigsFrom()

◆ CopyVolumeConfigsFrom()

◆ ForceSolid()

◆ ForkAndReset()

◆ ForkForFinalSolid()

◆ ForkForLogicalVolume()

◆ ForkForPlacement()

◆ GetBaseSolid()

◆ GetBuilderName()

◆ GetEffectiveDefaultUnit()

◆ GetFinalSolid()

◆ GetLogicalVolume()

◆ GetPhysTransform()

◆ GetPlacement()

◆ MakeLogicalVolume()

◆ MakePlacement()

◆ MakeSolid()

◆ operator=()

◆ OverridePlacementName()

◆ PlaceAndFork()

◆ ReflectZBaseSolid()

◆ ReflectZFinalSolid()

◆ set_shared_from_this_enabled()

◆ SetAlpha()

◆ SetAutoCopyNo()

◆ SetAutoPlacementNaming()

◆ SetBooleanName()

◆ SetColor() [1/2]

◆ SetColor() [2/2]

◆ SetCopyNo()

◆ SetDefaultUnit()

◆ SetLogicalVolume()

◆ SetMaterial()

◆ SetMother()

◆ SetName()

◆ SetPhysOffset()

◆ SetPhysRotation()

◆ SetPhysTransform()

◆ SetSurfaceCheck()

◆ SetVisibility()

◆ shared_from_this() [1/2]

◆ shared_from_this() [2/2]

◆ SolidConstructor()

◆ StackPhysOffset()

◆ StackPhysRotation()

◆ StackPhysTransform()

◆ ToVolumeBuilder()

Friends And Related Symbol Documentation

◆ i_shared_ptr

◆ i_shared_ptr< VolumeBuilderCore >

◆ StructureBuilderBase

◆ VB::CreateAssembly

◆ VolumeBuilderBase

Member Data Documentation

◆ is_enabled_