VolumeBuilderBase.hh

Go to the documentation of this file.

#pragma once
#ifndef VOLUMEBUILDER_HH
#define VOLUMEBUILDER_HH
#include <optional>
#include "Linkable.hh"
#include "IVolumeBuilder.hh"
#include "ISolidBuilder.hh"
#include "VolumeBuilderConfigs.hh"
/*
 
 * VolumeMaker.hh
 *
 * Created on: Jun 19, 2024
 *      Author: D. S. Leonard
 * Implicit or explicit misrepresentation authorship is not protected under any license.
 * See RZBuilder.hh for main documentation.
 *
 *s
 
 */
//#define SHARED_WRAPPER  DLG4::i_shared_ptr
#include <vector>
#include "i_shared_ptr.hh"
#include <VolumeBuildersTypes.hh>
 
 
// #define FIXME(msg) static_assert(false, "FIXME: " msg)
 
//#include "DetectorConstruction_includes.hh"
#include "PlacementNameRegistry.hh"
#include <G4Material.hh>
#include "G4Colour.hh"  // why?  It's in above.
#include "G4VPhysicalVolume.hh"
#include "G4UnionSolid.hh"
#include <G4ThreeVector.hh>
#include <mutex>
#include <memory>
#include <unordered_map>
#include "AssemblyCore.hh"
 
//#include "VolumeBuilderCore.hh"
 
namespace DLG4::VolumeBuilders::_internals_ {
 
    class VolumeBuilderCore;
    template <typename U>
    class VolumeBuilderBase;
 
    template <typename U>
    class VolumeBuilderBase: public ENABLE_SHARED_WRAPPER<U>, public ISolidBuilder
                         , public IVolumeBuilder {
        using DerivedPtr = SharedPtr<U>;
 
        // limit public(protected) API by using friendship.
        // Much of this can't even be handledby protected.
        // Specifically factories (normal) and the type-erasing pseudo-inheritance (StructureBuilder)
        template <typename>
        friend class VolumeBuilderBase;
        friend class VolumeBuilderCore;
        friend class AssemblyCore;
        template <typename>
        friend class StructureBuilderBase;
        friend class StructureBuilderCore;
        friend FromG4VSolid VB::CreateFromG4VSolid(G4VSolid *solid);
        friend Assembly VB::CreateAssembly(G4String names);
        friend class RZBuilderCore;
        friend class BoxBuilderCore;
        friend class FromG4VSolidCore;
 
    public:
        [[nodiscard]] G4VPhysicalVolume *GetPlacement() final;
 
        DerivedPtr MakePlacement();
 
 
        DerivedPtr PlaceAndFork() {
            this->MakePlacement();
            auto clone = this->ForkForPlacement(); // default/preset options
            return clone;
        }
 
        [[nodiscard]] G4LogicalVolume *GetLogicalVolume() final;
 
        [[nodiscard]] G4VSolid *GetBaseSolid() final;
 
        [[nodiscard]] G4VSolid *GetFinalSolid() final;
 
 
        DerivedPtr MakeLogicalVolume(
            G4Material *material = nullptr, G4String name = std::string());
 
        DerivedPtr MakeSolid();
 
        DerivedPtr SetName(const G4String &name);
 
        DerivedPtr AddUnion(const VolumeBuilder &other,
            const Unit3Vec &offset = {CLHEP::mm, 0, 0, 0},
            G4RotationMatrix *rotation = nullptr);
        DerivedPtr AddSubtraction(const VolumeBuilder &other,
            const Unit3Vec &offset = {CLHEP::mm, 0, 0, 0},
            G4RotationMatrix *rotation = nullptr);
        DerivedPtr AddIntersection(const VolumeBuilder &other,
            const Unit3Vec &offset = {CLHEP::mm, 0, 0, 0},
            G4RotationMatrix *rotation = nullptr);
        DerivedPtr AddBoolean(
            const VolumeBuilder &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); // default if uncalled is false.
 
        DerivedPtr SetVisibility(bool x = true);
 
        // ... inside the VolumeBuilder class declaration ...
 
        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 {
            return {placement_configs_->rotation, placement_configs_->translation};
        }
 
 
        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
            // in assembly/hierarchies, name change derives through parent
            );
 
        DerivedPtr CopyPlacementConfigsFrom(const VolumeBuilder &other);
 
        DerivedPtr CopyVolumeConfigsFrom(const VolumeBuilder &other);
 
        DerivedPtr SetDefaultUnit(G4double unit);
 
        G4double GetEffectiveDefaultUnit() const;
        DerivedPtr AddTo(BuilderViewList &list) const;
 
        DerivedPtr AddTo(StructureViewList &list) const;
 
        DerivedPtr AddTo(Assembly &assembly) const;
 
        ~VolumeBuilderBase() override;
 
 
        G4String GetBuilderName() const;
 
    protected:
        G4VSolid *SolidConstructor(const G4String &name) override = 0;
 
        // base implementation of non-fluent clone.
        SharedPtr<IStructureBuilder> clone_impl() const override;
 
    private:
        //Methods with basically protected intent
        // But for now, keep them private and require explicit friend access
        // ctors only useable through explicitly granted (friendship) inheritance...
 
        VolumeBuilder ToVolumeBuilder() const override;
        StructureBuilder ToStructureView() const override;
 
        VolumeBuilderBase();
        DerivedPtr SetSolid(G4VSolid *solid);
 
        DerivedPtr Clone() const {
            // This call is NOT DIRECTLY polymorphic.  It calls the VolumeBuilder base clone_impl().
            // Internally THAT calls polymorphic clone to create the structure_ptr and recreate the view.
            // We have to re-cast the result.
            i_shared_ptr<IStructureBuilder> base_cloned_ptr = this->clone_impl();
            return std::static_pointer_cast<U>(base_cloned_ptr);
        }
 
 
        template <typename T, typename std::enable_if_t<std::is_base_of_v<IStructureBuilder, T>,
            int>  = 0>
        VolumeBuilderBase(const SharedPtr<T> &other, SET_LINK_TYPE);
 
        VolumeBuilderBase &operator=(const VolumeBuilderBase &other) = delete;
        DerivedPtr MakeFinalSolid(G4String boolean_name = "");
        VolumeBuilderBase(const VolumeBuilderBase &other);
 
        VolumeBuilderBase(VolumeBuilderBase &&) noexcept = default;
 
        G4VSolid *GetSolidPtr() const {
            return this->solid_ptr_.get_mutable();
        };
 
        //Configs (re-linked by copy-ctors)
        ONCE_MUTABLE Linkable<BuilderConfigs> builder_configs_{BuilderConfigs{}};
        ONCE_MUTABLE Linkable<BooleanConfigs> boolean_configs_{BooleanConfigs{}};
        ONCE_MUTABLE Linkable<VolumeConfigs> lv_configs_{VolumeConfigs{}};
        ONCE_MUTABLE Linkable<PlacementConfigs> placement_configs_{PlacementConfigs{}};
 
        //Products (sometimes copied by copy methods)
        ONCE_MUTABLE Linkable<G4VSolid> solid_ptr_{}; // child can and should create the solid
        ONCE_MUTABLE Linkable<G4VSolid> final_solid_ptr_{};
        ONCE_MUTABLE Linkable<G4LogicalVolume> logicvol_ptr_{};
        ONCE_MUTABLE Linkable<G4VPhysicalVolume> placement_{};
 
 
        void StoreIStructurePtr(const IStructurePtr &istructure_ptr);
 
        void StoreBuilderView(const VolumeBuilder &builder_view);
 
 
        //Unsaved data, left out of configs to be reset on all copy operations.
        bool explicit_copyno_set_ = false;
        bool explicit_physical_copy_name_set_ = false;
        G4String placement_name_override_ = ""; // Will be derived from boolean_name_ by default
 
        void SetSolid_impl(G4VSolid *solid);
        void SetLogicalVolume_impl(G4LogicalVolume *logical_volume);
 
        //Some hard baked settings
        // let's pretend like we'd ever care about resource management:
        static constexpr bool has_ownership_{false}; // for future resource control
        static constexpr bool enable_full_lazy_builds{true};
        // Allows full chain lazy building.  Off for now.
 
        //Methods with truly private intent.
 
        // Propagate transforms
        void PropagateTransform();
 
 
        void ApplyAttributes_();
        G4String GetPlacementBaseName() const;
 
        [[nodiscard]] G4String GetLogicVolName() const; // should this be pulic?
 
        // these validators may trigger lazy build of buildable products needed for the build:
        void ValidateForPVBuild(std::string const &site = std::string());
        void ValidateForVolumeBuild(std::string const &site = std::string());
        void ValidateForBooleanBuild(std::string const &site = std::string());
        // These helper validators just check that the product isn't already made:
        void ValidateSolidNotBuilt(const std::string &operation) const;
        void ValidateBooleanNotBuilt(const std::string &operation) const;
        void ValidateLogicalNotBuilt(const std::string &operation) const;
        void ValidatePlacementNotBuilt(const std::string &operation) const;
 
        // For Geant, we need things left persistent, but this is a poor way even for this hack:
        static void make_persistent(const std::shared_ptr<void> &obj);
 
        G4ThreeVector ProvisionUnits(const Unit3Vec &vec) const;
 
        // Private static helper
        // method(s) used by the instance methods
 
        static void NoNameCheck(const std::string &name, const std::string &site) {
            if (name.empty()) {
                throw std::runtime_error("Error in " + site + " ,"
                                         "for builder named: " + name + "\n"
                                         " Must provide a new name");
            }
        }
    };
} // namespace VolumeBuilder
 
 
//The implementation:
#include "VolumeBuilderBase.hpp"
#endif
 
/* TODO
 * Need more derived classes for boxes and stuff!
 * [] Propagate validators into all config methods.
 * []  Validators needed in RZBuilder still.
 * [] review make_persistent vs no-op deleters, and add upfront protection.  make_persistent may need templating.
 * []   use self-owned shared_ptr trick (intentional cycle) instead of make_peristent.
 * [] A fill and copy would great.
 * [] Structure builder lacks recursive clone of placement_configs_.children
 
FromG4VSolid (rename?-> SolidAdapterBuilder)
Bonus
*
* [] consider adding overlap check option to command line for easier use.
* */