DLG4::VolumeBuilders: FromG4VSolid Class Reference

#include <FromG4VSolid.hh>

Collaboration diagram for FromG4VSolid:

Public Member Functions
	FromG4VSolid (const FromG4VSolid &other)

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

G4VPhysicalVolume *	GetPlacement () final

DerivedPtr	MakePlacement ()

DerivedPtr	PlaceAndFork ()

G4LogicalVolume *	GetLogicalVolume () final

G4VSolid *	GetBaseSolid () final

G4VSolid *	GetFinalSolid () final

DerivedPtr	MakeLogicalVolume (G4Material *material=nullptr, G4String name=std::string())

DerivedPtr	MakeSolid ()

DerivedPtr	SetName (const G4String &name)

DerivedPtr	AddUnion (const BuilderView &other, const Unit3Vec &offset={CLHEP::mm, 0, 0, 0}, G4RotationMatrix *rotation=nullptr)

DerivedPtr	AddSubtraction (const BuilderView &other, const Unit3Vec &offset={CLHEP::mm, 0, 0, 0}, G4RotationMatrix *rotation=nullptr)

DerivedPtr	AddIntersection (const BuilderView &other, const Unit3Vec &offset={CLHEP::mm, 0, 0, 0}, G4RotationMatrix *rotation=nullptr)

DerivedPtr	AddBoolean (const BuilderView &other, bool is_subtraction=false, bool is_intersection=false, const Unit3Vec &offset={CLHEP::mm, 0, 0, 0}, G4RotationMatrix *rotation=nullptr)

DerivedPtr	SetMaterial (G4Material *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 Unit3Vec &offset={CLHEP::mm, 0, 0, 0})

DerivedPtr	StackPhysOffset (const Unit3Vec &offset={CLHEP::mm, 0, 0, 0})

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 BuilderView &mother)

DerivedPtr	SetAutoPlacementNaming (bool set)

DerivedPtr	SetAutoCopyNo (bool set)

DerivedPtr	ReflectZFinalSolid ()

DerivedPtr	ReflectZBaseSolid ()

virtual 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 BuilderView &other)

DerivedPtr	CopyVolumeConfigsFrom (const BuilderView &other)

DerivedPtr	SetDefaultUnit (G4double unit)

G4double	GetEffectiveDefaultUnit () const

DerivedPtr	AddTo (BuilderViewList &list) const

DerivedPtr	AddTo (StructureViewList &list) const

DerivedPtr	AddTo (AssemblyPtr &assembly) const

BuilderView	ToBuilderView () const override

StructureView	ToStructureView () const override

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

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

Friends
class	VolumeBuilder< FromG4VSolid >

class	VolumeBuilderReference

FromG4VSolidPtr	CreateFromG4VSolidBuider (G4VSolid *solid)

Detailed Description

A solid buider class that just wrap an existing G4VSolid.

See also: VolumeBuilder for inherited methods.

// Created by @author Douglas S. Leonard on @date 6/8/25.  All rights Reserved.
// See related files for license, if any is provided.
//
// @ brief A stubbed VolumeBuilder Factory to create a builder from Any geant Solid.
// Only the out-of-class static Factory CreateFromG4VSolid() is exposed.
// Use it to configure logical volume and placement with VolumeBuilder from a standard G4VSolid.
///

Definition at line 35 of file FromG4VSolid.hh.

Constructor & Destructor Documentation

◆ FromG4VSolid()

FromG4VSolid ( const FromG4VSolid & other )

Definition at line 35 of file FromG4VSolid.cc.

                                                        :
        VolumeBuilder<FromG4VSolid>(other) {
        // Call base class copy constructor
        set_shared_from_this_enabled(false);
        SetName(other.GetBuilderName());
        solid_ptr_.Link(other.solid_ptr_);
        set_shared_from_this_enabled(true);
    }

Member Function Documentation

◆ AddBoolean()

VolumeBuilder< FromG4VSolid >::DerivedPtr AddBoolean	(	const BuilderView &	other,
		bool	is_subtraction = `false`,
		bool	is_intersection = `false`,
		const Unit3Vec &	offset = `{CLHEP::mm, 0, 0, 0}`,
		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 VolumeReferencePtr
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 218 of file VolumeBuilder.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()

VolumeBuilder< FromG4VSolid >::DerivedPtr AddIntersection	(	const BuilderView &	other,
		const Unit3Vec &	offset = `{CLHEP::mm, 0, 0, 0}`,
		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 VolumeReferencePtr
offset	Offset applied to solid
rotation	Applied to solid

Returns: The builder

Definition at line 202 of file VolumeBuilder.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()

VolumeBuilder< FromG4VSolid >::DerivedPtr AddSubtraction	(	const BuilderView &	other,
		const Unit3Vec &	offset = `{CLHEP::mm, 0, 0, 0}`,
		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 VolumeReferencePtr
offset	Offset applied to solid
rotation	Applied to solid

Returns: The builder

Definition at line 198 of file VolumeBuilder.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]

VolumeBuilder< FromG4VSolid >::DerivedPtr AddTo ( AssemblyPtr & assembly ) const

inherited

Add the builder an assembly geometrically joined manipulation.

Parameters

assembly The assembly to add to.

Returns: the builder

Definition at line 625 of file VolumeBuilder.hpp.

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

◆ AddTo() [2/3]

VolumeBuilder< FromG4VSolid >::DerivedPtr AddTo ( BuilderViewList & list ) const

inherited

Definition at line 607 of file VolumeBuilder.hpp.

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

◆ AddTo() [3/3]

VolumeBuilder< FromG4VSolid >::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 616 of file VolumeBuilder.hpp.

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

◆ AddUnion()

VolumeBuilder< FromG4VSolid >::DerivedPtr AddUnion	(	const BuilderView &	other,
		const Unit3Vec &	offset = `{CLHEP::mm, 0, 0, 0}`,
		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 VolumeReferencePtr
offset	Offset applied to solid
rotation	Applied to solid

Returns: The builder

Definition at line 194 of file VolumeBuilder.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

overrideprotectedvirtualinherited

Implements IStructureBuilder.

Definition at line 644 of file VolumeBuilder.hpp.

                                                        {
        const U &derived_ref = static_cast<const U &>(*this); // downcast
        auto retval = new U(derived_ref);                     // copy
        auto shared_ptr = i_shared_ptr<U>(retval);
        return shared_mutable_this(retval); // wrap and return.
    }

◆ CopyPlacementConfigsFrom()

VolumeBuilder< FromG4VSolid >::DerivedPtr CopyPlacementConfigsFrom ( const BuilderView & 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 560 of file VolumeBuilder.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()

VolumeBuilder< FromG4VSolid >::DerivedPtr CopyVolumeConfigsFrom ( const BuilderView & 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 571 of file VolumeBuilder.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()

VolumeBuilder< FromG4VSolid >::DerivedPtr ForceSolid ( bool x = true )

inherited

Returns: The builder

Definition at line 263 of file VolumeBuilder.hpp.

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

◆ ForkAndReset()

VolumeBuilder< FromG4VSolid >::DerivedPtr ForkAndReset ( const G4String & new_name ) const

virtualinherited

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 494 of file VolumeBuilder.hpp.

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

◆ ForkForFinalSolid()

VolumeBuilder< FromG4VSolid >::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 505 of file VolumeBuilder.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()

VolumeBuilder< FromG4VSolid >::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 520 of file VolumeBuilder.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()

VolumeBuilder< FromG4VSolid >::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 537 of file VolumeBuilder.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 135 of file VolumeBuilder.hpp.

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

◆ GetBuilderName()

G4String GetBuilderName ( ) const

inherited

Definition at line 637 of file VolumeBuilder.hpp.

                                        {
        return this->builder_configs_->name;
    }

◆ GetEffectiveDefaultUnit()

G4double GetEffectiveDefaultUnit ( ) const

inherited

Get the builder default unit or global if not set.

Returns: The active default unit.

Definition at line 597 of file VolumeBuilder.hpp.

                                                 {
        auto temp = builder_configs_.get();
        auto local = temp->default_unit;
        //        auto local = builder_configs_->default_unit;
        auto global = BuilderConfigs::global_default_unit;
        G4double default_unit = local.value_or(global);
        return default_unit;
    }

◆ 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 143 of file VolumeBuilder.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 123 of file VolumeBuilder.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 383 of file VolumeBuilder.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 88 of file VolumeBuilder.hpp.

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

◆ MakeLogicalVolume()

VolumeBuilder< FromG4VSolid >::DerivedPtr MakeLogicalVolume	(	G4Material *	material = `nullptr`,
		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	Pointer to material to use.
name	Optional explicit name for logical volume. Normally already derived from builder/solid name.

Returns: This builder.

Definition at line 157 of file VolumeBuilder.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_.ConstructAndLink(final_solid_ptr_,
            lv_configs_->material,
            name);
 
        ApplyAttributes_();
        return this->shared_from_this();
    }

◆ MakePlacement()

VolumeBuilder< FromG4VSolid >::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 98 of file VolumeBuilder.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()

VolumeBuilder< FromG4VSolid >::DerivedPtr MakeSolid ( )

inherited

Make the G4VSolid.

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

Returns: The builder

Definition at line 165 of file VolumeBuilder.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=()

FromG4VSolid & operator= ( const FromG4VSolid & other )

delete

◆ OverridePlacementName()

VolumeBuilder< FromG4VSolid >::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 394 of file VolumeBuilder.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 109 of file VolumeBuilder.hh.

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

◆ ReflectZBaseSolid()

VolumeBuilder< FromG4VSolid >::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 478 of file VolumeBuilder.hpp.

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

◆ ReflectZFinalSolid()

VolumeBuilder< FromG4VSolid >::DerivedPtr ReflectZFinalSolid ( )

inherited

Configure final solid to be flipped in z.

Definition at line 468 of file VolumeBuilder.hpp.

                                     {
        if (final_solid_ptr_) {
            throw std::runtime_error("Error VolumeBuilder::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()

VolumeBuilder< FromG4VSolid >::DerivedPtr SetAlpha ( G4double alpha )

inherited

Parameters

alpha

Returns: The builder

Definition at line 256 of file VolumeBuilder.hpp.

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

◆ SetAutoCopyNo()

VolumeBuilder< FromG4VSolid >::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 451 of file VolumeBuilder.hpp.

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

◆ SetAutoPlacementNaming()

VolumeBuilder< FromG4VSolid >::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 438 of file VolumeBuilder.hpp.

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

◆ SetBooleanName()

VolumeBuilder< FromG4VSolid >::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 299 of file VolumeBuilder.hpp.

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

◆ SetColor() [1/2]

VolumeBuilder< FromG4VSolid >::DerivedPtr SetColor ( const G4Colour & color )

inherited

Parameters

color

Returns: The builder

Definition at line 248 of file VolumeBuilder.hpp.

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

◆ SetColor() [2/2]

VolumeBuilder< FromG4VSolid >::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 240 of file VolumeBuilder.hpp.

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

◆ SetCopyNo()

VolumeBuilder< FromG4VSolid >::DerivedPtr SetCopyNo ( G4int pCopyNo )

inherited

Set the copy number for the placement.

Parameters

pCopyNo Copy number.

Returns: This builder for chaining.

Definition at line 403 of file VolumeBuilder.hpp.

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

◆ SetDefaultUnit()

VolumeBuilder< FromG4VSolid >::DerivedPtr SetDefaultUnit ( G4double 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 CLHEP::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 unit to set, ex: CLHEP::mm

Returns
The builder (allows chaining)

Definition at line 590 of file VolumeBuilder.hpp.

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

◆ SetLogicalVolume()

VolumeBuilder< FromG4VSolid >::DerivedPtr SetLogicalVolume ( G4LogicalVolume * logical_volume )

inherited

Directly Provide a Logical Volume Instead of using the builder.

Parameters

logical_volume

Definition at line 288 of file VolumeBuilder.hpp.

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

◆ SetMaterial()

VolumeBuilder< FromG4VSolid >::DerivedPtr SetMaterial ( G4Material * material )

inherited

/**

Parameters

material

Returns: The builder

Definition at line 233 of file VolumeBuilder.hpp.

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

◆ SetMother()

VolumeBuilder< FromG4VSolid >::DerivedPtr SetMother ( const BuilderView & 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 olumeReferencePtrparameter accepts a builder or a G4VSolid through implicit ctor

Returns: This builder for chaining.

Definition at line 425 of file VolumeBuilder.hpp.

                                                     {
        if (!mother) {
            throw std::runtime_error("Error in VolumeBuilder::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()

VolumeBuilder< FromG4VSolid >::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 172 of file VolumeBuilder.hpp.

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

◆ SetPhysOffset()

VolumeBuilder< FromG4VSolid >::DerivedPtr SetPhysOffset ( const Unit3Vec & offset = {CLHEP::mm, 0, 0, 0} )

inherited

Set the translation vector for placement.

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

Examples: SetPhysOffset({CLHEP::cm, 1, 2, 3}) // 1cm, 2cm, 3cm SetPhysOffset({1, 2, 3}) // Uses default default unit (usually mm) SetDefaultUnit(CLHEP::cm); SetPhysOffset({1, 2, 3}) // 1cm, 2cm, 3cm SetDefaultUnit(1); SetPhysOffset({10*CLHEP::mm, 20*CLHEP::mm, 30*CLHEP::mm}) // Values already have units

Parameters

offset Translation vector. See method description for details.

Returns: This builder for chaining.

Definition at line 338 of file VolumeBuilder.hpp.

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

◆ SetPhysRotation()

VolumeBuilder< FromG4VSolid >::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 308 of file VolumeBuilder.hpp.

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

◆ SetPhysTransform()

VolumeBuilder< FromG4VSolid >::DerivedPtr SetPhysTransform ( const UnitlessG4Transform3D & new_transform )

inherited

Set the G4Transform3D for placment The tranformation provided is meant to be UNITLESS unless you SetDefaultUnit(1).

Otherwise ex: SetDefaultUnit(CLHEP::cm) and proivde a UNITLESS transform. To supply units for each G4Tranform3D separately, just call SetDefaultUnit(unit) before each call. Will overwite/replace rotation and translation.

Parameters

new_transform Translation vector.

Returns: This builder for chaining.

Definition at line 364 of file VolumeBuilder.hpp.

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

◆ SetSurfaceCheck()

VolumeBuilder< FromG4VSolid >::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 411 of file VolumeBuilder.hpp.

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

◆ SetVisibility()

VolumeBuilder< FromG4VSolid >::DerivedPtr SetVisibility ( bool x = true )

inherited

Parameters

Returns: The builder

Definition at line 271 of file VolumeBuilder.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;
            }
        }

◆ StackPhysOffset()

VolumeBuilder< FromG4VSolid >::DerivedPtr StackPhysOffset ( const Unit3Vec & offset = {CLHEP::mm, 0, 0, 0} )

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 349 of file VolumeBuilder.hpp.

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

◆ StackPhysRotation()

VolumeBuilder< FromG4VSolid >::DerivedPtr StackPhysRotation ( const G4RotationMatrix & stacked_rot )

inherited

Like SetPhysRotation but stacks with previous transformations in order applied.

Parameters

stacked_rot

Returns: The builder

Definition at line 320 of file VolumeBuilder.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()

VolumeBuilder< FromG4VSolid >::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 371 of file VolumeBuilder.hpp.

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

◆ ToBuilderView()

BuilderView ToBuilderView ( ) const

overridevirtualinherited

Implements IStructureBuilder.

Definition at line 633 of file VolumeBuilder.hpp.

                                          {
        // calls the BuilderView copy/convert ctor::
        // presently the i_shared converter only works with l-value.
        std::shared_ptr<U> builder_std_ptr =
            std::const_pointer_cast<U>(this->shared_from_this());
        auto x = DerivedPtr(builder_std_ptr);
        return BuilderView(x);
    }

◆ ToStructureView()

StructureView ToStructureView ( ) const

overridevirtualinherited

Implements IStructureBuilder.

Definition at line 635 of file VolumeBuilder.hpp.

                                              {
        // calls the structure view copy/convert ctor:
        std::shared_ptr<U> builder_std_ptr =
            std::const_pointer_cast<U>(this->shared_from_this());
        auto x = DerivedPtr(builder_std_ptr);
        return StructureView(x);
    }

Friends And Related Symbol Documentation

◆ CreateFromG4VSolidBuider

FromG4VSolidPtr CreateFromG4VSolidBuider ( G4VSolid * solid )

friend

◆ VolumeBuilder< FromG4VSolid >

friend class VolumeBuilder< FromG4VSolid >

friend

Definition at line 35 of file FromG4VSolid.hh.

◆ VolumeBuilderReference

friend class VolumeBuilderReference

friend

Definition at line 37 of file FromG4VSolid.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/FromG4VSolid.hh
src/FromG4VSolid.cc

Public Member Functions

Protected Member Functions

Protected Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ FromG4VSolid()

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]

◆ StackPhysOffset()

◆ StackPhysRotation()

◆ StackPhysTransform()

◆ ToBuilderView()

◆ ToStructureView()

Friends And Related Symbol Documentation

◆ CreateFromG4VSolidBuider

◆ VolumeBuilder< FromG4VSolid >

◆ VolumeBuilderReference

Member Data Documentation

◆ is_enabled_