VolumeBuilderTypes.hh

Go to the documentation of this file.

#pragma once
//
// Created by Douglas S. Leonard on 6/18/25.  All rights Reserved
// See related files for license, if any is provided.
//
// Types for VolumeBuilder classes
 
#ifndef VOLUMEBUILDERTYPES_HH
#define VOLUMEBUILDERTYPES_HH
#include <G4ThreeVector.hh>
#include <memory>
#include <optional>
#include <vector>
 
#include "disableable_shared_from_this.hh"
#include "i_shared_ptr.hh"
 
#define ONCE_MUTABLE mutable  // for linkable objects
 
namespace DLG4::VolumeBuilders {
    // Base template alias
    template <typename T>
    using SharedPtr = i_shared_ptr<T>;
    class ISolidBuilder;
    class IStructureBuilder;
    class IVolumeBuilder;
    template <typename T>
    class VolumeBuilder;
    class VolumeBuilderReference;
    class RZBuilder;
    class BoxBuilder;
    class FromG4VSolid;
    template <typename T>
    class StructureBuilder;
    class StructureBuilderReference;
    class Assembly;
 
    using ISolidPtr = SharedPtr<ISolidBuilder>;
 
    using IStructurePtr = SharedPtr<IStructureBuilder>;
 
    using BuilderView = SharedPtr<VolumeBuilderReference>;
    using StructureView = SharedPtr<StructureBuilderReference>;
 
    using RZBuilderPtr = SharedPtr<RZBuilder>;
 
    using FromG4VSolidPtr = SharedPtr<FromG4VSolid>;
 
    using BoxBuilderPtr = SharedPtr<BoxBuilder>;
 
 
    using AssemblyPtr = SharedPtr<Assembly>;
 
    using BuilderViewList = std::vector<BuilderView>;
 
    using StructureViewList = std::vector<StructureView>;
 
    // For the template base class
    template <typename U>
    using VolumeBuilderPtr = SharedPtr<U>;
 
    template <typename U>
    using ENABLE_SHARED_WRAPPER = Utilities::disableable_shared_from_this<U>;
 
    using UnitlessG4Transform3D = G4Transform3D;
    using Unitless3Vec = G4ThreeVector;
    class Unit3Vec {
    public:
        double x, y, z;
        std::optional<double> units;
 
        // 3-value constructor - no units specified, raw values
        Unit3Vec(double x, double y, double z) : x(x), y(y), z(z), units(std::nullopt) {
        }
 
        // 4-value constructor - units specified, scale the values
        Unit3Vec(double u, double x, double y, double z) : x(x), y(y), z(z), units(u) {
        }
 
        Unit3Vec(double u, const Unitless3Vec &vec) :
            x(vec.getX()), y(vec.getY()), z(vec.getZ()), units(u) {
        }
 
        [[nodiscard]] G4ThreeVector apply_units(const double dflt_unit) const {
            auto vec = G4ThreeVector(0, 0, 0);
            auto unit = this->units.value_or(dflt_unit);
            vec.setX(this->x * unit);
            vec.setY(this->y * unit);
            vec.setZ(this->z * unit);
            return vec;
        }
    };
 
    template <typename T>
    std::shared_ptr<T> shared_mutable_this(const std::enable_shared_from_this<T> *obj) {
        // Call shared_from_this() (returns shared_ptr<const T> if obj is const)
        auto sp_const = obj->shared_from_this();
 
        // Cast away constness safely
        return std::const_pointer_cast<std::remove_const_t<T>>(sp_const);
    }
}
#endif  //VOLUMEBUILDERTYPES_HH