geant4Dependencies.cc

Go to the documentation of this file.

// geant4Dependencies.cc : dependency checks used by factory default implementations.
 
// guts
#include "gutilities.h"
 
// g4system
#include "gsystemConventions.h"
#include "g4objectsFactory.h"
 
bool G4ObjectsFactory::checkSolidDependencies(const GVolume* s,
                                              std::unordered_map<std::string,
                                                                 G4Volume*>* g4s) {
    // Dependency check applies only to solids that rely on other solids (copy/boolean operations).
    // Ordinary primitives have no extra prerequisites.
    const auto& copyOf    = s->getCopyOf();
    const auto& solidsOpr = s->getSolidsOpr();
    std::string gsystem   = s->getSystem();
 
    std::string message;
 
    if (copyOf) { message = ", copyOf: " + *copyOf; }
    else if (solidsOpr) { message = ", solidsOpr: " + *solidsOpr; }
 
    log->debug(
        NORMAL, "%1 checkSolidDependencies: checking dependencies for <%2>%3", className(), s->getName(),
        message);
 
    /*──────────────────────────────────── copyOf: volumeName ───────────────────────────────────*/
    if (copyOf) {
        auto volume_copy = gsystem + "/" + *copyOf;
        if (getSolidFromMap(volume_copy, g4s) != nullptr) {
            log->info(2, "<%1> is a copy of <%2>, which already exists", s->getName(), volume_copy);
            return true;
        }
        log->info(
            2, "<%1> is a copy of <%2>, which already exists, which does not exist yet", s->getName(),
            volume_copy);
        return false;
    }
 
    /*──────────────────────────────────── Boolean solid operations ──────────────────────────────*/
    else if (solidsOpr) {
        // The solids operation is expected to be tokenized into: left operand, operator, right operand.
        std::vector<std::string> solidOperations =
            gutilities::getStringVectorFromString(*solidsOpr);
 
        // A leading "@" marks GEMC2's Operation:@ absolute-coordinate placement (see buildSolid.cc); it
        // is not an operand, so drop it before checking the operand dependencies.
        if (!solidOperations.empty() && solidOperations[0] == "@") {
            solidOperations.erase(solidOperations.begin());
        }
 
        if (solidOperations.size() == 3) {
            // Supported operators: + (union), - (subtraction), * (intersection).
            if (solidOperations[1] == "+" || solidOperations[1] == "-" || solidOperations[1] == "*") {
                auto left = getSolidFromMap(solidOperations[0], g4s);
                if (left == nullptr) left = getSolidFromMap(gsystem + "/" + solidOperations[0], g4s);
                auto right = getSolidFromMap(solidOperations[2], g4s);
                if (right == nullptr) right = getSolidFromMap(gsystem + "/" + solidOperations[2], g4s);
 
                // Operand solids must exist before the boolean solid can be created.
                if (left != nullptr && right != nullptr)
                    return true;
            }
            return false;
        }
        return false;
    }
 
    /*────────────────────────────────────    default path     ──────────────────────────────────*/
    return true; // ordinary primitive – no extra prerequisites
}
 
bool G4ObjectsFactory::checkLogicalDependencies([[maybe_unused]] const GVolume* s,
                                                [[maybe_unused]] std::unordered_map<std::string,
                                                    G4Volume*>* g4s) {
    // Placeholder for future logical checks (materials/sensitive detector prerequisites).
    return true;
}
 
// Verify that both the candidate logical volume and its mother logical volume exist before placement.
// Header documentation is authoritative; this implementation comment is intentionally brief.
bool G4ObjectsFactory::checkPhysicalDependencies(const GVolume* s,
                                                 std::unordered_map<std::string,
                                                                    G4Volume*>* g4s) {
    std::string vname      = s->getG4Name();
    std::string motherName = s->getG4MotherName();
 
    // Candidate wrapper must exist in the map before we can reason about its logical/physical state.
    if (g4s->find(vname) == g4s->end()) {
        log->info(2, "dependencies: %1 not found in gvolume map yet.", vname);
        return false;
    }
 
    // Candidate logical must exist (or be available through a copy source).
    if (getLogicalFromMap(vname, g4s) == nullptr) {
        // If it is a copy, require that the source logical volume exists.
        const auto& copyOf = s->getCopyOf();
        if (copyOf) {
            auto gsystem     = s->getSystem();
            auto volume_copy = gsystem + "/" + *copyOf;
            if (getLogicalFromMap(volume_copy, g4s) == nullptr) {
                log->info(2, "dependencies: copy %1 logical volume not found yet.", volume_copy);
                return false;
            }
        }
        else {
            log->info(2, "dependencies: %1 logical volume not found yet.", vname);
            return false;
        }
    }
 
    // Mother logical must exist unless this is the world volume.
    if (motherName != gsystem::MOTHEROFUSALL && getLogicalFromMap(motherName, g4s) == nullptr) {
        log->info(2, "dependencies: %1 mother <%2> logical volume not found yet.", vname, motherName);
        return false;
    }
 
    // Everything satisfied – emit verbose trace.
    if (motherName != gsystem::MOTHEROFUSALL) {
        log->info(
            2,
            "dependencies: <%1> and mother <%2> logical volumes are found. Ready to build or get physical "
            "volume.", vname, motherName);
    }
    else {
        log->info(
            2, "dependencies: <%1> logical volume is found. Ready to build or get physical volume.", vname);
    }
    return true;
}