RZBuilder.hh

Go to the documentation of this file.

#pragma once
 
/*
 * RZBuilder.hh
 *
 *  Created on: Jun 19, 2024
 *      Author: D. S. Leonard
 *
 *      The main user class is presently RZBuilder
 *      Which creates polycones and polyhedrals From z plane definitions.
 *      VolumeMaker which it inherits from provides more generic extended functionality (syntax helpers) to it.
 *      Such as logical volume creation, unions/subtractions, and vis attribute settings.
 *      Features/Benefits
 *      -Unit is separate and remembered for cleaner/simpler dimensioning
 *                        (no * mm everwhere, no double unit application, no forgotten unit).
 *      -z=0 point can be outside of object, allowing many objects to reference from a single z.
 *      -Much simpler than using unions for multi-plane objects
 *         - No overlap/z-shift/half-height/sign confusions for every union part.
 *      -no half height math everywhere (or doubled or forgotten application of it).
 *      -Simplified union syntax when still needed.
 *      -Simplified vis_att syntax
 *      -Simplified logical volume construction.
 *      -Polymorphic methods could help in automation in principle.
 *
 *
 */
 
#include "VolumeBuildersTypes.hh"
#include "VolumeBuilder.hh"
#include "StructureBuilderReference.hh"
// ReSharper disable once CppUnusedIncludeDirective
#include <memory>
 
namespace DLG4::VolumeBuilders {
    struct RZPlane {
        G4double unit; // unit
        G4double IR;   // inner radius
        G4double OR;   // outer radius
        G4double z;
        RZPlane() = default;
 
        RZPlane(G4double u, G4double ir, G4double or_, G4double z_)
            : unit(u), IR(ir), OR(or_), z(z_) {
        }
    };
 
    struct RZPlaneUnitless {
        G4double IR{0}; // inner radius
        G4double OR{0}; // outer radius
        G4double z{0};
    };
 
    // See other Derived classes, or better yet the Factories "Topic" in the Doxygen html manual,
    // For Factories for other types of shapes or sources.
 
    // Parameters after name are only needed for polyhedra or angular information:
    RZBuilderPtr CreatePolyhedraBuilder(
        const G4String &name, int sides, G4double phi_start = 0., G4double phi_tot = 360);
 
    RZBuilderPtr CreatePolyconeBuilder(
        const G4String &name, G4double phi_start = 0., G4double phi_tot = 360);
 
    RZBuilderPtr CreateCylinderBuilder(G4double unit, const G4String &name,
        G4double endz, G4double height, G4double OR, G4double IR = 0);
 
    RZBuilderPtr CreateCylinderBuilder(const G4String &name,
        G4double endz, G4double height, G4double OR, G4double IR = 0);
}
 
namespace DLG4::VolumeBuilders::_internals_ {
    class RZBuilder final: public VolumeBuilder<RZBuilder> {
    public:
        friend class VolumeBuilderReference;
        friend class VolumeBuilder<RZBuilder>; // shouldn't be needed, maybe isn't now.
        template <typename T>
        friend class i_shared_ptr; // needed in principle, but maybe not for this class.
 
        // Friend all the factories.  Keeping them external is easier for users, but more boilerplate.
        friend RZBuilderPtr VB::CreatePolyhedraBuilder(
            const G4String &name, int sides, G4double phi_start, G4double phi_tot);
        friend RZBuilderPtr VB::CreatePolyconeBuilder(const G4String &name, G4double phi_start,
            G4double phi_tot);
        friend RZBuilderPtr VB::CreateCylinderBuilder(G4double unit, const G4String &name,
            G4double endz, G4double height, G4double OR, G4double IR);
        friend RZBuilderPtr VB::CreateCylinderBuilder(const G4String &name,
            G4double endz, G4double height, G4double OR, G4double IR);
 
        virtual RZBuilderPtr SetNumSides(G4double N);
 
        RZBuilderPtr AddPlane(const RZPlane &plane);
        RZBuilderPtr AddPlane(G4double IR, G4double OR, G4double z);
 
        RZBuilderPtr AddPlane(G4double unit, G4double IR, G4double OR, G4double z);
 
 
        RZBuilderPtr AddPlanes(const std::vector<RZPlane> &planes);
        RZBuilderPtr AddPlanes(const std::vector<RZPlaneUnitless> &planes);
        RZBuilderPtr AddPlanes(G4double unit, const std::vector<RZPlaneUnitless> &planes);
 
        RZBuilderPtr ReflectZSolidConfig();
 
        RZBuilderPtr FillSolidConfig();
 
 
    protected:
        G4VSolid *SolidConstructor(const G4String &name) override {
            return (this->*MakeSolidFunctionPtr_)(name);
        }
 
    private:
        explicit RZBuilder(const G4String &name, G4double init_phi_start = 0.,
            G4double init_phi_tot = 360, int init_sides = 4);
 
        //These will become public as MakeSolid() in derived classes.
        //RZBuilder(const RZBuilder &other, const G4String &new_name);
        G4VSolid *MakePolycone(const G4String &name);
 
        G4VSolid *MakePolyhedra(const G4String &name);
 
        //There is no MakeCylinder() because it's a special case of Polycone'
 
        RZBuilder(const RZBuilder &other);
 
 
        G4int sides_{4}; // only for polyhedra
        // private raw copy ctor
        // values and checks...
        G4double phi_start_deg_{0};
        G4double phi_tot_deg{360};
 
        G4VSolid * (RZBuilder::*MakeSolidFunctionPtr_)(const G4String &name) = nullptr;
 
        // plane data:
        int num_planes_{0};
        std::vector<G4double> z_;
        std::vector<G4double> IR_;
        std::vector<G4double> OR_;
 
        RZBuilder() = default;
        RZBuilder(RZBuilder &&) noexcept = delete;
 
        // RZBuilderPtr Clone() const override {
        //     return RZBuilderPtr(new RZBuilder(*this));
        // }
    };
}
 
// technical notes
//  You cannot have polymorphic clone in C++ with reference return, so we need a pointer return.
//  Then the copies use -> where originals use .  (dot) which is annoying.  So we use Create() factory methods to
//  Create the originals always as pointers too.
//  But then we make ctors private, to simplify the interface.  And might as well use smart pointers while we're at it.
//  Seems this is a common pattern, but that's C++ :P
//
// * return from a base class Clone() returns a base class type and slices derived class members.
//   It's actually possible to have a simple Clone(): Derived(Base) {}   in Derived, especially if derived has no data
//   to reconstruct, but smart pointer return and factories are the "usual" way.
//
//   In C# all of this would be simple.