StructureBuilder.hh

Go to the documentation of this file.

#pragma once
#ifndef STRUCTUREBUILDER_HH
#define STRUCTUREBUILDER_HH
#include <optional>
#include "Linkable.hh"
#include "ISolidBuilder.hh"
#include "VolumeBuilderConfigs.hh"
#include <G4Transform3D.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 "VolumeBuilderTypes.hh"
 
 
// #define FIXME(msg) static_assert(false, "FIXME: " msg)
 
//#include "DetectorConstruction_includes.hh"
#include "G4Colour.hh"
#include "G4VPhysicalVolume.hh"
#include <G4ThreeVector.hh>
#include <mutex>
#include <memory>
#include <stdexcept>
//#include "StructureBuilder.hh"
 
namespace DLG4::VolumeBuilders {
    template <typename U>
    class StructureBuilder: public ENABLE_SHARED_WRAPPER<U>, public IStructureBuilder {
        using DerivedPtr = SharedPtr<U>;
 
        // we need access to the other templates for copy
        template <typename>
        friend class VolumeBuilder;
        friend class StructureBuilderReference;
        friend class Assembly;
        friend AssemblyPtr CreateAssembly(G4String name);
        template <typename>
        friend class StructureBuilder;
        //allow i_shared_ptr access to our converting ctors
        //This way they get instantly wrapped!
 
        friend class i_shared_ptr<StructureBuilder<U>>;
 
    public:
        //Methods specific to structures/assemblies....
 
 
        DerivedPtr MakePlacement();
        DerivedPtr ForkForPlacement(
            std::optional<int> copy_no = std::nullopt
            , const G4String &name_override = "");
 
        DerivedPtr ForkForLogicalVolume(const G4String &new_name);
 
 
        DerivedPtr PlaceAndFork();
 
 
        DerivedPtr SetName(const G4String &name);
 
        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 is_visible = true);
 
 
        // ... inside the StructureBuilder class declaration ...
 
        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 &stacked_transform);
 
        [[nodiscard]] G4Transform3D GetPhysTransform() const {
            return {placement_configs_->rotation, placement_configs_->translation};
        }
 
 
        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 CopyPlacementConfigsFrom(const BuilderView &other);
 
 
        DerivedPtr SetDefaultUnit(G4double unit);
 
        G4double GetEffectiveDefaultUnit() const;
 
 
        ~StructureBuilder() override;
 
        G4String GetBuilderName() const;
 
    protected:
        G4VSolid *SolidConstructor(const G4String &name) override = 0;
 
    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...
 
        friend class RZBuilder;
        friend class StructureBuilderReference;
        friend class FromG4VSolid;
 
 
        StructureBuilder();
 
        DerivedPtr Clone() const {
            i_shared_ptr<IStructureBuilder> base_cloned_ptr = this->clone_impl();
            // really is a static cast in principle, but just to catch programming bugs:
            auto retval = i_dynamic_pointer_cast<U>(base_cloned_ptr);
            return retval;
        }
 
        SharedPtr<IStructureBuilder> clone_impl() const override;
 
        StructureView ToStructureView() const override;
 
        BuilderView ToBuilderView() const override;
 
 
        template <typename T, typename std::enable_if_t<std::is_base_of_v<IStructureBuilder, T>,
            int>  = 0>
        StructureBuilder(const SharedPtr<T> &other, SET_LINK_TYPE);
 
 
        StructureBuilder &operator=(const StructureBuilder &other) = delete;
        StructureBuilder(const StructureBuilder &other);
 
        StructureBuilder(StructureBuilder &&) 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_{};
        bool was_placed_ = false; // set when assembly is placed.
 
        // Interface pointer for type erased class access (Copied in linking ctor only)
 
 
        //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
 
 
        //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.
 
        [[nodiscard]] G4String GetLogicVolName() const; // should this be pulic?
 
        void ValidateForPVBuild(std::string const &site = std::string());
        void ValidatePlacementNotBuilt(const std::string &operation) const;
 
 
        // Nothing below here but  implementation for some private static helper
        // methods 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 StructureBuilder
 
 
//#include "StructureBuilder.hpp"
 
//The implementation:
#endif