DLG4::VolumeBuilders: BoxBuilder Class Reference

#include <BoxBuilder.hh>

Collaboration diagram for BoxBuilder:

Public Member Functions
BoxBuilderPtr	SetXSize (G4double x_size)

BoxBuilderPtr	SetYSize (G4double y_size)

BoxBuilderPtr	SetZSize (G4double z_size)

BoxBuilderPtr	SetXEdges (G4double x_edge1, G4double x_edge2)

BoxBuilderPtr	SetYEdges (G4double y_edge1, G4double y_edge2)

BoxBuilderPtr	SetZEdges (G4double z_edge1, G4double z_edge2)

BoxBuilderPtr	SetXEdgeDelta (G4double x_edge, G4double x_delta)

BoxBuilderPtr	SetYEdgeDelta (G4double y_edge, G4double y_delta)

BoxBuilderPtr	SetZEdgeDelta (G4double z_edge, G4double z_delta)

BoxBuilderPtr	SetInternalOffset (G4double x, G4double y, G4double z)

BoxBuilderPtr	SetXSize (G4double unit, G4double x_size)

BoxBuilderPtr	SetYSize (G4double unit, G4double y_size)

BoxBuilderPtr	SetZSize (G4double unit, G4double z_size)

BoxBuilderPtr	SetXEdges (G4double unit, G4double x_edge1, G4double x_edge2)

BoxBuilderPtr	SetYEdges (G4double unit, G4double y_edge1, G4double y_edge2)

BoxBuilderPtr	SetZEdges (G4double unit, G4double z_edge1, G4double z_edge2)

BoxBuilderPtr	SetXEdgeDelta (G4double unit, G4double x_edge, G4double x_delta)

BoxBuilderPtr	SetYEdgeDelta (G4double unit, G4double y_edge, G4double y_delta)

BoxBuilderPtr	SetZEdgeDelta (G4double unit, G4double z_edge, G4double z_delta)

BoxBuilderPtr	SetInternalOffset (G4double unit, G4double x, G4double y, G4double z)

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
G4VSolid *	SolidConstructor (const G4String &name) override

SharedPtr< IStructureBuilder >	clone_impl () const override

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

Friends
class	VolumeBuilderReference

class	VolumeBuilder< BoxBuilder >

template<typename T >
class	i_shared_ptr

BoxBuilderPtr	CreateBoxBuilder (const G4String &name)

BoxBuilderPtr	CreateBoxBuilder (const G4String &name, G4double unit)

BoxBuilderPtr	CreateDeltasBoxBuilder (const G4String &name, G4double edge_x, G4double x_delta, G4double edge_y, G4double y_delta, G4double edge_z, G4double z_delta)

BoxBuilderPtr	CreateDeltasBoxBuilder (G4double unit, const G4String &name, G4double edge_x, G4double x_delta, G4double edge_y, G4double y_delta, G4double edge_z, G4double z_delta)

BoxBuilderPtr	CreateZDeltaBoxBuilder (const G4String &name, G4double x_full_size, G4double y_full_size, G4double edge_z, G4double z_delta)

BoxBuilderPtr	CreateZDeltaBoxBuilder (G4double unit, const G4String &name, G4double x_full_size, G4double y_full_size, G4double edge_z, G4double z_delta)

BoxBuilderPtr	CreateCenteredBoxBuilder (const G4String &name, G4double x_full_size, G4double y_full_size, G4double z_full_size)

BoxBuilderPtr	CreateCenteredBoxBuilder (G4double unit, const G4String &name, G4double x_full_size, G4double y_full_size, G4double z_full_size)

BoxBuilderPtr	CreateEdgesBoxBuilder (const G4String &name, G4double x_edge1, G4double x_edge2, G4double y_edge1, G4double y_edge2, G4double z_edge1, G4double z_edge2)

BoxBuilderPtr	CreateEdgesBoxBuilder (G4double unit, const G4String &name, G4double x_edge1, G4double x_edge2, G4double y_edge1, G4double y_edge2, G4double z_edge1, G4double z_edge2)

Detailed Description

Builder class for simple Box solids.

Use the CreateXXX() factory methods to create the buiders. In particular we can create boxes that are not referenced to the center!!

See also: VolumeBuilder for inherited methods.

Definition at line 206 of file BoxBuilder.hh.

Member Function Documentation

◆ AddBoolean()

VolumeBuilder< BoxBuilder >::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< BoxBuilder >::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< BoxBuilder >::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< BoxBuilder >::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< BoxBuilder >::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< BoxBuilder >::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< BoxBuilder >::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< BoxBuilder >::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< BoxBuilder >::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< BoxBuilder >::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< BoxBuilder >::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< BoxBuilder >::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< BoxBuilder >::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< BoxBuilder >::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< BoxBuilder >::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< BoxBuilder >::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< BoxBuilder >::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();
    }

◆ OverridePlacementName()

VolumeBuilder< BoxBuilder >::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< BoxBuilder >::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< BoxBuilder >::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< BoxBuilder >::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< BoxBuilder >::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< BoxBuilder >::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< BoxBuilder >::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< BoxBuilder >::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< BoxBuilder >::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< BoxBuilder >::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< BoxBuilder >::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();
    }

◆ SetInternalOffset() [1/2]

BoxBuilderPtr SetInternalOffset	(	G4double	unit,
		G4double	x,
		G4double	y,
		G4double	z
	)

Definition at line 296 of file BoxBuilder.cc.

                                            {
        return SetInternalOffsetDimensioned(x * unit, y * unit, z * unit);
    }

◆ SetInternalOffset() [2/2]

BoxBuilderPtr SetInternalOffset	(	G4double	x,
		G4double	y,
		G4double	z
	)

Definition at line 204 of file BoxBuilder.cc.

                          {
        return SetInternalOffset(this->GetEffectiveDefaultUnit(), x, y, z);
    }

◆ SetLogicalVolume()

VolumeBuilder< BoxBuilder >::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< BoxBuilder >::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< BoxBuilder >::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< BoxBuilder >::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< BoxBuilder >::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< BoxBuilder >::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< BoxBuilder >::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< BoxBuilder >::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< BoxBuilder >::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();
    }

◆ SetXEdgeDelta() [1/2]

BoxBuilderPtr SetXEdgeDelta	(	G4double	unit,
		G4double	x_edge,
		G4double	x_delta
	)

Definition at line 260 of file BoxBuilder.cc.

                                {
        G4double size = std::abs(x_delta);
        G4double offset = x_edge + x_delta / 2.0;
        SetXSizeDimensioned(size * unit);
        return SetInternalOffsetDimensioned(
            offset * unit,
            this->builder_configs_->internal_offset.y(),
            this->builder_configs_->internal_offset.z()
            );
    }

◆ SetXEdgeDelta() [2/2]

BoxBuilderPtr SetXEdgeDelta	(	G4double	x_edge,
		G4double	x_delta
	)

Definition at line 192 of file BoxBuilder.cc.

                                                                                         {
        return SetXEdgeDelta(this->GetEffectiveDefaultUnit(), x_edge, x_delta);
    }

◆ SetXEdges() [1/2]

BoxBuilderPtr SetXEdges	(	G4double	unit,
		G4double	x_edge1,
		G4double	x_edge2
	)

Definition at line 223 of file BoxBuilder.cc.

                                {
        G4double size = std::abs(x_edge2 - x_edge1);
        G4double offset = (x_edge1 + x_edge2) / 2.0;
        SetXSizeDimensioned(size * unit);
        return SetInternalOffsetDimensioned(
            offset * unit,
            this->builder_configs_->internal_offset.y(),
            this->builder_configs_->internal_offset.z()
            );
    }

◆ SetXEdges() [2/2]

BoxBuilderPtr SetXEdges	(	G4double	x_edge1,
		G4double	x_edge2
	)

Definition at line 180 of file BoxBuilder.cc.

                                                                                      {
        return SetXEdges(this->GetEffectiveDefaultUnit(), x_edge1, x_edge2);
    }

◆ SetXSize() [1/2]

BoxBuilderPtr SetXSize	(	G4double	unit,
		G4double	x_size
	)

Definition at line 210 of file BoxBuilder.cc.

                                                                                 {
        return SetXSizeDimensioned(x_size * unit);
    }

◆ SetXSize() [2/2]

BoxBuilderPtr SetXSize ( G4double x_size )

Definition at line 168 of file BoxBuilder.cc.

                                                            {
        return SetXSize(this->GetEffectiveDefaultUnit(), x_size);
    }

◆ SetYEdgeDelta() [1/2]

BoxBuilderPtr SetYEdgeDelta	(	G4double	unit,
		G4double	y_edge,
		G4double	y_delta
	)

Definition at line 272 of file BoxBuilder.cc.

                                {
        G4double size = std::abs(y_delta);
        G4double offset = y_edge + y_delta / 2.0;
        SetYSizeDimensioned(size * unit);
        return SetInternalOffsetDimensioned(
            this->builder_configs_->internal_offset.x(),
            offset * unit,
            this->builder_configs_->internal_offset.z()
            );
    }

◆ SetYEdgeDelta() [2/2]

BoxBuilderPtr SetYEdgeDelta	(	G4double	y_edge,
		G4double	y_delta
	)

Definition at line 196 of file BoxBuilder.cc.

                                                                                         {
        return SetYEdgeDelta(this->GetEffectiveDefaultUnit(), y_edge, y_delta);
    }

◆ SetYEdges() [1/2]

BoxBuilderPtr SetYEdges	(	G4double	unit,
		G4double	y_edge1,
		G4double	y_edge2
	)

Definition at line 235 of file BoxBuilder.cc.

                                {
        G4double size = std::abs(y_edge2 - y_edge1);
        G4double offset = (y_edge1 + y_edge2) / 2.0;
        SetYSizeDimensioned(size * unit);
        return SetInternalOffsetDimensioned(
            this->builder_configs_->internal_offset.x(),
            offset * unit,
            this->builder_configs_->internal_offset.z()
            );
    }

◆ SetYEdges() [2/2]

BoxBuilderPtr SetYEdges	(	G4double	y_edge1,
		G4double	y_edge2
	)

Definition at line 184 of file BoxBuilder.cc.

                                                                                      {
        return SetYEdges(this->GetEffectiveDefaultUnit(), y_edge1, y_edge2);
    }

◆ SetYSize() [1/2]

BoxBuilderPtr SetYSize	(	G4double	unit,
		G4double	y_size
	)

Definition at line 214 of file BoxBuilder.cc.

                                                                                 {
        return SetYSizeDimensioned(y_size * unit);
    }

◆ SetYSize() [2/2]

BoxBuilderPtr SetYSize ( G4double y_size )

Definition at line 172 of file BoxBuilder.cc.

                                                            {
        return SetYSize(this->GetEffectiveDefaultUnit(), y_size);
    }

◆ SetZEdgeDelta() [1/2]

BoxBuilderPtr SetZEdgeDelta	(	G4double	unit,
		G4double	z_edge,
		G4double	z_delta
	)

Definition at line 284 of file BoxBuilder.cc.

                                {
        G4double size = std::abs(z_delta);
        G4double offset = z_edge + z_delta / 2.0;
        SetZSizeDimensioned(size * unit);
        return SetInternalOffsetDimensioned(
            this->builder_configs_->internal_offset.x(),
            this->builder_configs_->internal_offset.y(),
            offset * unit
            );
    }

◆ SetZEdgeDelta() [2/2]

BoxBuilderPtr SetZEdgeDelta	(	G4double	z_edge,
		G4double	z_delta
	)

Definition at line 200 of file BoxBuilder.cc.

                                                                                         {
        return SetZEdgeDelta(this->GetEffectiveDefaultUnit(), z_edge, z_delta);
    }

◆ SetZEdges() [1/2]

BoxBuilderPtr SetZEdges	(	G4double	unit,
		G4double	z_edge1,
		G4double	z_edge2
	)

Definition at line 247 of file BoxBuilder.cc.

                                {
        G4double size = std::abs(z_edge2 - z_edge1);
        G4double offset = (z_edge1 + z_edge2) / 2.0;
        SetZSizeDimensioned(size * unit);
        return SetInternalOffsetDimensioned(
            this->builder_configs_->internal_offset.x(),
            this->builder_configs_->internal_offset.y(),
            offset * unit
            );
    }

◆ SetZEdges() [2/2]

BoxBuilderPtr SetZEdges	(	G4double	z_edge1,
		G4double	z_edge2
	)

Definition at line 188 of file BoxBuilder.cc.

                                                                                      {
        return SetZEdges(this->GetEffectiveDefaultUnit(), z_edge1, z_edge2);
    }

◆ SetZSize() [1/2]

BoxBuilderPtr SetZSize	(	G4double	unit,
		G4double	z_size
	)

Definition at line 218 of file BoxBuilder.cc.

                                                                                 {
        return SetZSizeDimensioned(z_size * unit);
    }

◆ SetZSize() [2/2]

BoxBuilderPtr SetZSize ( G4double z_size )

Definition at line 176 of file BoxBuilder.cc.

                                                            {
        return SetZSize(this->GetEffectiveDefaultUnit(), z_size);
    }

◆ 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 )

overrideprotectedvirtual

The polymorphic Solid constructor.

Implements VolumeBuilder< BoxBuilder >.

Definition at line 318 of file BoxBuilder.cc.

                                                               {
        if (this->solid_ptr_.get() != nullptr) {
            std::string error = "Error in BoxBuilder::SolidConstructor: A solid was already built\n"
                "You can copy and rename the builder to reset it and build again.";
            throw std::runtime_error(error);
        }
        G4cout << G4endl;
        G4cout << "New BoxBuilder:" << GetBuilderName() // lie and use the final transformed name
            << "x_size: " << x_size_ << " y_size: " << y_size_ << " z_size: " << z_size_ <<
            G4endl;
        G4cout << "Internal offset: " << this->builder_configs_->internal_offset << G4endl;
        return new G4Box(name, x_size_ / 2.0, y_size_ / 2.0, z_size_ / 2.0);
    }

◆ StackPhysOffset()

VolumeBuilder< BoxBuilder >::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< BoxBuilder >::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< BoxBuilder >::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

◆ CreateBoxBuilder [1/2]

BoxBuilderPtr CreateBoxBuilder ( const G4String & name )

friend

Definition at line 32 of file BoxBuilder.cc.

                                                         {
        auto object = BoxBuilderPtr(new BoxBuilder(name));
        return object;
    }

◆ CreateBoxBuilder [2/2]

BoxBuilderPtr CreateBoxBuilder	(	const G4String &	name,
		G4double	unit
	)

friend

Create an unconfigured Box Solid, for use with SetXEdges() etc...

Parameters

name	Base name to derive geometry object names from.
unit	unit for this call only (ex: CLHEP::mm)

Returns: The builder. Set configurations and then call .MakeSolid() and .MakeLogicalVolume() on it. See VolumeBuilder for inherited public methods including Union/Subtraction.

Definition at line 37 of file BoxBuilder.cc.

                                                                              {
        auto object = BoxBuilderPtr(new BoxBuilder(name));
        object->SetDefaultUnit(unit);
        return object;
    }

◆ CreateCenteredBoxBuilder [1/2]

BoxBuilderPtr CreateCenteredBoxBuilder	(	const G4String &	name,
		G4double	x_full_size,
		G4double	y_full_size,
		G4double	z_full_size
	)

friend

Create a Box solid.

Uses the global default unit

Parameters

name	Base name to derive geometry object names from.
x_full_size	FULL X size
y_full_size	FULL Y size
z_full_size	FULL Z size
name

Returns: The builder. Set configurations and then call .MakeSolid() and .MakeLogicalVolume() on it. See VolumeBuilder for inherited public methods including Union/Subtraction.

Definition at line 110 of file BoxBuilder.cc.

                                    {
        if (x_full_size <= 0 || y_full_size <= 0 || z_full_size <= 0) {
            throw std::invalid_argument("Error in CreateCenteredBoxBuilder(): for volume " + name
                                        + ": Sizes provided must be positive.\n");
        }
        auto object = BoxBuilderPtr(new BoxBuilder(name));
        object->SetXSize(x_full_size)
              ->SetYSize(y_full_size)
              ->SetZSize(z_full_size);
        return object;
    }

◆ CreateCenteredBoxBuilder [2/2]

BoxBuilderPtr CreateCenteredBoxBuilder	(	G4double	unit,
		const G4String &	name,
		G4double	x_full_size,
		G4double	y_full_size,
		G4double	z_full_size
	)

friend

Create a Box solid.

Parameters

unit	The unit to use for this call only (ex: CLHEP::mm)
name	Base name to derive geometry object names from.
x_full_size	FULL X size
y_full_size	FULL Y size
z_full_size	FULL Z size

Returns: The builder. Set configurations and then call .MakeSolid() and .MakeLogicalVolume() on it. See VolumeBuilder for inherited public methods including Union/Subtraction.

Definition at line 96 of file BoxBuilder.cc.

                                    {
        if (x_full_size <= 0 || y_full_size <= 0 || z_full_size <= 0) {
            throw std::invalid_argument("Error in CreateCenteredBoxBuilder(): for volume " + name
                                        + ": Sizes provided must be positive.\n");
        }
        auto object = BoxBuilderPtr(new BoxBuilder(name));
        object->SetXSize(unit, x_full_size)
              ->SetYSize(unit, y_full_size)
              ->SetZSize(unit, z_full_size);
        return object;
    }

◆ CreateDeltasBoxBuilder [1/2]

BoxBuilderPtr CreateDeltasBoxBuilder	(	const G4String &	name,
		G4double	edge_x,
		G4double	x_delta,
		G4double	edge_y,
		G4double	y_delta,
		G4double	edge_z,
		G4double	z_delta
	)

friend

Create a Box solid.

Uses the global default unit

Parameters

name	Base name to derive geometry object names from.
edge_x	The x reference of one end (either one)
x_delta	FULL X size, + or - from end_x.
edge_y	The y reference of one end (either one)
y_delta	FULL Y size. + or - from end_y.
edge_z	The z reference of one end (either one)
z_delta	Height, can be positive or negative (from z reference)

Returns: The builder. Set configurations and then call .MakeSolid() and .MakeLogicalVolume() on it. See VolumeBuilder for inherited public methods including Union/Subtraction.

Definition at line 56 of file BoxBuilder.cc.

                                                                               {
        auto object = BoxBuilderPtr(new BoxBuilder(name));
        object->SetXEdgeDelta(edge_x, x_delta)
              ->SetYEdgeDelta(edge_y, y_delta)
              ->SetZEdgeDelta(edge_z, z_delta);
        return object;
    }

◆ CreateDeltasBoxBuilder [2/2]

BoxBuilderPtr CreateDeltasBoxBuilder	(	G4double	unit,
		const G4String &	name,
		G4double	edge_x,
		G4double	x_delta,
		G4double	edge_y,
		G4double	y_delta,
		G4double	edge_z,
		G4double	z_delta
	)

friend

Create a Box solid.

Parameters

unit	The unit to use for this call only (ex: CLHEP::mm)
name	Base name to derive geometry object names from.
edge_x	The x reference of one end (either one)
x_delta	FULL X size, + or - from end_x.
edge_y	The y reference of one end (either one)
y_delta	FULL Y size. + or - from end_y.
edge_z	The z reference of one end (either one)
z_delta	Height, can be positive or negative (from z reference)

Returns: The builder. Set configurations and then call .MakeSolid() and .MakeLogicalVolume() on it. See VolumeBuilder for inherited public methods including Union/Subtraction.

Definition at line 44 of file BoxBuilder.cc.

                                {
        auto object = BoxBuilderPtr(new BoxBuilder(name));
        object->SetXEdgeDelta(unit, edge_x, x_delta)
              ->SetYEdgeDelta(unit, edge_y, y_delta)
              ->SetZEdgeDelta(unit, edge_z, z_delta);
        return object;
    }

◆ CreateEdgesBoxBuilder [1/2]

BoxBuilderPtr CreateEdgesBoxBuilder	(	const G4String &	name,
		G4double	x_edge1,
		G4double	x_edge2,
		G4double	y_edge1,
		G4double	y_edge2,
		G4double	z_edge1,
		G4double	z_edge2
	)

friend

Create a Box solid from edge coordinates.

Uses the global default unit

Parameters

name	Base name to derive geometry object names from.
x_edge1	One end of the box in the x-dimension.
x_edge2	The other end of the box in the x-dimension.
y_edge1	One end of the box in the y-dimension.
y_edge2	The other end of the box in the y-dimension.
z_edge1	One end of the box in the z-dimension.
z_edge2	The other end of the box in the z-dimension.

Returns: The builder. Set configurations and then call .MakeSolid() and .MakeLogicalVolume() on it. See VolumeBuilder for inherited public methods including Union/Subtraction.

Definition at line 124 of file BoxBuilder.cc.

                                                                                {
        auto object = BoxBuilderPtr(new BoxBuilder(name));
        object->SetXEdges(x_edge1, x_edge2)
              ->SetYEdges(y_edge1, y_edge2)
              ->SetZEdges(z_edge1, z_edge2);
        return object;
    }

◆ CreateEdgesBoxBuilder [2/2]

BoxBuilderPtr CreateEdgesBoxBuilder	(	G4double	unit,
		const G4String &	name,
		G4double	x_edge1,
		G4double	x_edge2,
		G4double	y_edge1,
		G4double	y_edge2,
		G4double	z_edge1,
		G4double	z_edge2
	)

friend

Create a Box solid from edge coordinates using a specified unit.

Parameters

unit	The unit to use for this call only (ex: CLHEP::mm)
name	Base name to derive geometry object names from.
x_edge1	One end of the box in the x-dimension.
x_edge2	The other end of the box in the x-dimension.
y_edge1	One end of the box in the y-dimension.
y_edge2	The other end of the box in the y-dimension.
z_edge1	One end of the box in the z-dimension.
z_edge2	The other end of the box in the z-dimension.

Returns: The builder. Set configurations and then call .MakeSolid() and .MakeLogicalVolume() on it. See VolumeBuilder for inherited public methods including Union/Subtraction.

Definition at line 134 of file BoxBuilder.cc.

                                {
        auto object = BoxBuilderPtr(new BoxBuilder(name));
        object->SetXEdges(unit, x_edge1, x_edge2)
              ->SetYEdges(unit, y_edge1, y_edge2)
              ->SetZEdges(unit, z_edge1, z_edge2);
        return object;
    }

◆ CreateZDeltaBoxBuilder [1/2]

BoxBuilderPtr CreateZDeltaBoxBuilder	(	const G4String &	name,
		G4double	x_full_size,
		G4double	y_full_size,
		G4double	edge_z,
		G4double	z_delta
	)

friend

Create a Box solid.

Uses the global default unit.

Parameters

name	Base name to derive geometry object names from.
x_full_size	FULL X size
y_full_size	FULL Y size
edge_z	Full Z size
z_delta	Full Z size

Returns: The builder. Set configurations and then call .MakeSolid() and .MakeLogicalVolume() on it. See VolumeBuilder for inherited public methods including Union/Subtraction.

Definition at line 82 of file BoxBuilder.cc.

                                {
        if (x_full_size <= 0 || y_full_size <= 0) {
            throw std::invalid_argument("Error in CreateZDeltaBoxBuilder(): for volume " + name
                                        + ": Sizes provided without end offsets must be positive.\n");
        }
        auto object = BoxBuilderPtr(new BoxBuilder(name));
        object->SetXSize(x_full_size)
              ->SetYSize(y_full_size)
              ->SetZEdgeDelta(edge_z, z_delta);
        return object;
    }

◆ CreateZDeltaBoxBuilder [2/2]

BoxBuilderPtr CreateZDeltaBoxBuilder	(	G4double	unit,
		const G4String &	name,
		G4double	x_full_size,
		G4double	y_full_size,
		G4double	edge_z,
		G4double	z_delta
	)

friend

Create a Box solid.

Parameters

unit	The unit to use for this call only (ex: CLHEP::mm)
name	Base name to derive geometry object names from.
x_full_size	FULL X size
y_full_size	FULL Y size
edge_z	Full Z size
z_delta	Full Z size

Returns: The builder. Set configurations and then call .MakeSolid() and .MakeLogicalVolume() on it. See VolumeBuilder for inherited public methods including Union/Subtraction.

Definition at line 67 of file BoxBuilder.cc.

                                                       {
        if (x_full_size <= 0 || y_full_size <= 0) {
            throw std::invalid_argument("Error in CreateZDeltaBoxBuilder(): for volume " + name
                                        + ": Sizes provided without end offsets must be positive.\n");
        }
        auto object = BoxBuilderPtr(new BoxBuilder(name));
        object->SetXSize(unit, x_full_size)
              ->SetYSize(unit, y_full_size)
              ->SetZEdgeDelta(unit, edge_z, z_delta);
        return object;
    }

◆ i_shared_ptr

template<typename T >

friend class i_shared_ptr

friend

Definition at line 211 of file BoxBuilder.hh.

◆ VolumeBuilder< BoxBuilder >

friend class VolumeBuilder< BoxBuilder >

friend

Definition at line 208 of file BoxBuilder.hh.

◆ VolumeBuilderReference

friend class VolumeBuilderReference

friend

Definition at line 208 of file BoxBuilder.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/BoxBuilder.hh
src/BoxBuilder.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()

◆ OverridePlacementName()

◆ PlaceAndFork()

◆ ReflectZBaseSolid()

◆ ReflectZFinalSolid()

◆ set_shared_from_this_enabled()

◆ SetAlpha()

◆ SetAutoCopyNo()

◆ SetAutoPlacementNaming()

◆ SetBooleanName()

◆ SetColor() [1/2]

◆ SetColor() [2/2]

◆ SetCopyNo()

◆ SetDefaultUnit()

◆ SetInternalOffset() [1/2]

◆ SetInternalOffset() [2/2]

◆ SetLogicalVolume()

◆ SetMaterial()

◆ SetMother()

◆ SetName()

◆ SetPhysOffset()

◆ SetPhysRotation()

◆ SetPhysTransform()

◆ SetSurfaceCheck()

◆ SetVisibility()

◆ SetXEdgeDelta() [1/2]

◆ SetXEdgeDelta() [2/2]

◆ SetXEdges() [1/2]

◆ SetXEdges() [2/2]

◆ SetXSize() [1/2]

◆ SetXSize() [2/2]

◆ SetYEdgeDelta() [1/2]

◆ SetYEdgeDelta() [2/2]

◆ SetYEdges() [1/2]

◆ SetYEdges() [2/2]

◆ SetYSize() [1/2]

◆ SetYSize() [2/2]

◆ SetZEdgeDelta() [1/2]

◆ SetZEdgeDelta() [2/2]

◆ SetZEdges() [1/2]

◆ SetZEdges() [2/2]

◆ SetZSize() [1/2]

◆ SetZSize() [2/2]

◆ shared_from_this() [1/2]

◆ shared_from_this() [2/2]

◆ SolidConstructor()

◆ StackPhysOffset()

◆ StackPhysRotation()

◆ StackPhysTransform()

◆ ToBuilderView()