Collaboration diagram for VolumeBuilderBase:

[legend]

Public Member Functions
G4VPhysicalVolume *	GetPlacement () final

DerivedPtr	MakePlacement ()

DerivedPtr	PlaceAndFork ()

G4LogicalVolume *	GetLogicalVolume () final

G4VSolid *	GetBaseSolid () final

G4VSolid *	GetFinalSolid () final

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

DerivedPtr	MakeSolid ()

DerivedPtr	SetName (const G4String &name)

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

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

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

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

DerivedPtr	SetMaterial (const VBHelpers::G4MaterialPtrOrString &material)

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

DerivedPtr	SetColor (const G4Colour &color)

DerivedPtr	SetAlpha (G4double alpha)

DerivedPtr	ForceSolid (bool x=true)

DerivedPtr	SetVisibility (bool x=true)

DerivedPtr	SetLogicalVolume (G4LogicalVolume *logical_volume)

DerivedPtr	SetBooleanName (const G4String &name)

DerivedPtr	SetPhysRotation (const G4RotationMatrix &rot)

DerivedPtr	StackPhysRotation (const G4RotationMatrix &stacked_rot)

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

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

DerivedPtr	SetPhysTransform (const UnitlessG4Transform3D &new_transform)

DerivedPtr	StackPhysTransform (const UnitlessG4Transform3D &new_transform)

G4Transform3D	GetPhysTransform () const final

DerivedPtr	OverridePlacementName (const G4String &pName)

DerivedPtr	SetCopyNo (G4int pCopyNo)

DerivedPtr	SetSurfaceCheck (G4bool pSurfChk)

DerivedPtr	SetMother (const VolumeBuilder &mother)

DerivedPtr	SetAutoPlacementNaming (bool set)

DerivedPtr	SetAutoCopyNo (bool set)

DerivedPtr	ReflectZFinalSolid ()

DerivedPtr	ReflectZBaseSolid ()

DerivedPtr	ForkAndReset (const G4String &new_name) const

DerivedPtr	ForkForFinalSolid (const G4String &new_name)

DerivedPtr	ForkForLogicalVolume (const G4String &new_name)

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

DerivedPtr	CopyPlacementConfigsFrom (const VolumeBuilder &other)

DerivedPtr	CopyVolumeConfigsFrom (const VolumeBuilder &other)

DerivedPtr	SetDefaultUnit (Length unit)

Length	GetEffectiveDefaultUnit () const

DerivedPtr	AddTo (BuilderViewList &list) const

DerivedPtr	AddTo (StructureViewList &list) const

DerivedPtr	AddTo (Assembly &assembly) const

	~VolumeBuilderBase () override

G4String	GetBuilderName () const

template<typename U >
	VolumeBuilderBase (const VolumeBuilderBase< U > &other)

template<typename T , std::enable_if_t< std::is_base_of_v< IStructureBuilder, T >, int > >
	VolumeBuilderBase (const SharedPtr< T > &other, std::true_type)

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=0

SharedPtr< IStructureBuilder >	clone_impl () const override

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

Friends
template<typename >
class	VolumeBuilderBase

class	VolumeBuilderCore

class	AssemblyCore

template<typename >
class	StructureBuilderBase

class	StructureBuilderCore

class	RZBuilderCore

class	BoxBuilderCore

class	FromG4VSolidCore

FromG4VSolid	VB::CreateFromG4VSolid (G4VSolid *solid)

Assembly	VB::CreateAssembly (G4String names)

Detailed Description

template<typename U>
class DLG4::VolumeBuilders::_internals_::VolumeBuilderBase

VolumeBuilder: Common functionality for volume builder classes.

Includes material and attribute setting, and union/subtraction methods. This is Not a user class. Only usable through inheritance to extend class functionality. Return most things by pointer to the derived class So we can chain operations (fluent interface).

Template Parameters

U	CRTP paramter for the derived class.

Definition at line 61 of file VolumeBuilderBase.hh.

Constructor & Destructor Documentation

◆ ~VolumeBuilderBase()

template<typename U >

~VolumeBuilderBase ( )

override

Destructor Normally does not delete volume objects.

Geant takes care of that.

Definition at line 109 of file VolumeBuilderBase.hpp.

                             {
        // optionally release resources (default)
        // ReSharper disable once CppIfCanBeReplacedByConstexprIf
        if (!has_ownership_) {
            // This is SO wrong.  This should be done at CREATION of members,
            // not deletion of class.
            // But it works for now and we're super restrictive on creation.
            final_solid_ptr_.make_persistent();
            solid_ptr_.make_persistent();
            logicvol_ptr_.make_persistent();
            placement_.make_persistent();
        }
    }

◆ VolumeBuilderBase() [1/2]

template<typename U >

VolumeBuilderBase ( const VolumeBuilderBase & other )

Definition at line 78 of file VolumeBuilderBase.hpp.

                                            : builder_configs_(other.builder_configs_),
                                            boolean_configs_(other.boolean_configs_),
                                            lv_configs_(other.lv_configs_),
                                            placement_configs_(other.placement_configs_) {
        // avoid masked bugs from stale view:
        StoreBuilderView(nullptr);
        StoreIStructurePtr(nullptr);
        // don't copy products since they can only be linked once.
        // Copy methods will do that.
    }

◆ VolumeBuilderBase() [2/2]

template<typename U >

template<typename T , std::enable_if_t< std::is_base_of_v< IStructureBuilder, T >, int > >

VolumeBuilderBase	(	const SharedPtr< T > &	other,
		std::true_type
	)

Definition at line 95 of file VolumeBuilderBase.hpp.

                       : builder_configs_(other->builder_configs_,SET_LINK),
                         boolean_configs_(other->boolean_configs_,SET_LINK),
                         lv_configs_(other->lv_configs_, SET_LINK),
                         placement_configs_(other->placement_configs_,SET_LINK),
                         solid_ptr_(other->solid_ptr_,SET_LINK),
                         logicvol_ptr_(other->logicvol_ptr_,SET_LINK),
                         placement_(other->placement_,SET_LINK) {
        builder_configs_->istructure_ptr = IStructurePtr(other);
    }

Member Function Documentation

◆ AddTo()

template<typename U >

VolumeBuilderBase::DerivedPtr AddTo ( BuilderViewList & list ) const

Definition at line 1002 of file VolumeBuilderBase.hpp.

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

◆ clone_impl()

template<typename U >

SharedPtr< IStructureBuilder > clone_impl ( ) const

overrideprotectedvirtual

Implements IStructureBuilder.

Reimplemented in VolumeBuilderCore.

Definition at line 994 of file VolumeBuilderBase.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.
    }

◆ GetBuilderName()

template<typename U >

G4String GetBuilderName ( ) const

Definition at line 970 of file VolumeBuilderBase.hpp.

                                        {
        return this->builder_configs_->name;
    }

◆ MakeLogicalVolume()

template<typename U >

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

Basically never needed now.

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

Parameters

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

Returns: This builder.

Definition at line 124 of file VolumeBuilderBase.hpp.

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

◆ MakePlacement()

template<typename U >

VolumeBuilderBase::DerivedPtr MakePlacement ( )

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 460 of file VolumeBuilderBase.hpp.

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

◆ MakeSolid()

template<typename U >

VolumeBuilderBase::DerivedPtr MakeSolid ( )

Make the G4VSolid.

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

Returns: The builder

Definition at line 935 of file VolumeBuilderBase.hpp.

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

◆ 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;
        }

◆ SetName()

template<typename U >

VolumeBuilderBase::DerivedPtr SetName ( const G4String & name )

SetName Sets name used for solid and derived product names.

Parameters

name The name

Returns: The builder

Definition at line 400 of file VolumeBuilderBase.hpp.

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

◆ shared_from_this() [1/2]

template<typename T >

std::shared_ptr< T > shared_from_this ( )

inlineinherited

Definition at line 44 of file disableable_shared_from_this.hh.

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

◆ shared_from_this() [2/2]

template<typename T >

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

inlineinherited

Definition at line 52 of file disableable_shared_from_this.hh.

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

◆ SolidConstructor()

template<typename U >

G4VSolid * SolidConstructor ( const G4String & name )

overrideprotectedpure virtual

polymorphic access to solid construction

Implements IStructureBuilder.

Implemented in BoxBuilderCore, RZBuilderCore, and VolumeBuilderCore.

◆ StackPhysOffset()

template<typename U >

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

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 567 of file VolumeBuilderBase.hpp.

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

◆ StackPhysRotation()

template<typename U >

VolumeBuilderBase::DerivedPtr StackPhysRotation ( const G4RotationMatrix & stacked_rot )

Like SetPhysRotation but stacks with previous transformations in order applied.

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

Parameters

stacked_rot

Returns: The builder

Definition at line 543 of file VolumeBuilderBase.hpp.

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

◆ StackPhysTransform()

template<typename U >

VolumeBuilderBase::DerivedPtr StackPhysTransform ( const UnitlessG4Transform3D & new_transform )

Like SetPhysTransform but stacks with previous transformations in order applied.

Parameters

new_transform

Returns: The builder

Definition at line 583 of file VolumeBuilderBase.hpp.

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

friend

Definition at line 75 of file VolumeBuilderBase.hh.

◆ StructureBuilderCore

template<typename U >

friend class StructureBuilderCore

friend

A type-erased (data shared view) view of a builder or assembly, ie a "structure.".

Can hold other structures, creating placement hierarchies. Behaves like a buidler, but only for logical volume properties and placement related commands. You can set VisAtt on a structure, and can set offsets and rotations of the whole structure for placement.

While this base view only supports limited methods, it is fully polymorphic and builder objects internally can trigger their full build chain.

This derived clas really exists for parallelism with VolumeBuilderCore.

See also: VolumeBuilder for inherited methods.

Definition at line 76 of file VolumeBuilderBase.hh.

◆ VB::CreateAssembly

template<typename U >

Assembly VB::CreateAssembly ( G4String names )

friend

◆ VB::CreateFromG4VSolid

template<typename U >

FromG4VSolid VB::CreateFromG4VSolid ( G4VSolid * solid )

friend

◆ VolumeBuilderBase

template<typename U >

template<typename >

friend class VolumeBuilderBase

friend

Definition at line 71 of file VolumeBuilderBase.hh.

◆ VolumeBuilderCore

template<typename U >

friend class VolumeBuilderCore

friend

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

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

See also: VolumeBuilder for inherited methods.

Definition at line 72 of file VolumeBuilderBase.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:

Public Member Functions

Protected Member Functions

Protected Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ ~VolumeBuilderBase()

◆ VolumeBuilderBase() [1/2]

◆ VolumeBuilderBase() [2/2]

Member Function Documentation

◆ AddTo()

◆ clone_impl()

◆ GetBuilderName()

◆ MakeLogicalVolume()

◆ MakePlacement()

◆ MakeSolid()

◆ set_shared_from_this_enabled()

◆ SetName()

◆ shared_from_this() [1/2]

◆ shared_from_this() [2/2]

◆ SolidConstructor()

◆ StackPhysOffset()

◆ StackPhysRotation()

◆ StackPhysTransform()

Friends And Related Symbol Documentation

◆ AssemblyCore

◆ BoxBuilderCore

◆ FromG4VSolidCore

◆ RZBuilderCore

◆ StructureBuilderBase

◆ StructureBuilderCore

◆ VB::CreateAssembly

◆ VB::CreateFromG4VSolid

◆ VolumeBuilderBase

◆ VolumeBuilderCore

Member Data Documentation

◆ is_enabled_