GGSWolowitz.cpp

// GEANT4 headers
#include "G4Box.hh"
#include "G4Colour.hh"
#include "G4GeometryManager.hh"
#include "G4LogicalVolume.hh"
#include "G4LogicalVolumeStore.hh"
#include "G4Material.hh"
#include "G4PVPlacement.hh"
#include "G4PVReplica.hh"
#include "G4PhysicalVolumeStore.hh"
#include "G4SolidStore.hh"
#include "G4VisAttributes.hh"
#ifdef USE_G4GDML
#include "G4GDMLParser.hh"
#endif
#include "G4RunManager.hh"
#include "G4TransportationManager.hh"

// VGM headers
#ifdef USE_TGEOROOT
#include "Geant4GM/volumes/Factory.h"
#include "RootGM/volumes/Factory.h"
#include "TGeoManager.h"
#endif

// GGS headers
#include "GGSVersion.h" //Automatically generated by the CMake configuration system
#include "geometry/GGSVGeometryConstruction.h"
#include "geometry/pluginmanagers/GGSGeoPluginManager.h"
#include "utils/GGSSmartLog.h"

namespace GGSWolowitz {
G4String outputFile = "GGSGeometry";
G4String geoDataCard = "";
G4String geometryFile = "";
#ifdef USE_G4GDML
const G4String defaultOutputType = "g4.gdml";
#else
const G4String defaultOutputType = "tgeo.root";
#endif
G4String outputType = defaultOutputType;
G4String schemaLocation = "http://service-spi.web.cern.ch/service-spi/app/releases/GDML/schema/gdml.xsd";
G4String detectorFlag = "";
} // namespace GGSWolowitz

void usage() {
  std::cout << "This program is used to convert GGS detector geometry into other geometry formats.\n";
  std::cout << "Built with support for "
#ifdef USE_G4GDML
               "g4.gdml"
#ifdef USE_TGEOROOT
               " "
#endif
#endif
#ifdef USE_TGEOROOT
               "tgeo.root"
#ifdef USE_TGEOGDML
               " tgeo.gdml"
#endif
#endif
               ".\n";
  // clang-format off
  std::cout << "\nUsage: GGSWolowitz [options] \n";
  std::cout << "\nOptions:\n";
  std::cout << " -o,  --output-file FILE     output filename [default: output.gdml]\n";
  std::cout << " -g,  --geometry FILE        full path and name of the geometry .so file\n";
  std::cout << " -gd, --geo-data-card FILE   data card filename for geometry configuration [default: not set]\n";
  std::cout << " -t,  --output-type TYPE     output type (possible values: "
#ifdef USE_G4GDML
               "g4.gdml, "
#endif
#ifdef USE_TGEOROOT
               "tgeo.root, "
#ifdef USE_TGEOGDML
               "tgeo.gdml, "
#endif
#endif
               "default: "
            << GGSWolowitz::defaultOutputType << ")\n";
  std::cout << " -u, --gdml-schema-location  url of schema location [default: http://service-spi.web.cern.ch/service-spi/app/releases/GDML/schema/gdml.xsd]\n";
  std::cout << " -v, --verbose               be verbose [default: false]\n";
  std::cout << " -V, --version               displays software version and exit\n";
  std::cout << " -h, --help                  display this help and exit\n";
  // clang-format on
}

void version() {
  std::cout << "GGSWolowitz geometry software\n";
  std::cout << "Using GGS " << GGSVERSION << std::endl;
}

using namespace GGSWolowitz;

int HandleInputPar(int argc, const char **argv) {
  static const std::string routineName("HandleInputPar");
  // Set verbose level to print warnings about unrecognized options
  GGSSmartLog::verboseLevel = GGSSmartLog::WARNING;
  int vLevel = GGSSmartLog::INFO;
  if (argc > 1) {
    int i = 1;
    while (i < argc) {
      if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) {
        usage();
        return 1;
      }
      // -----------------------------------------------------//
      if (!strcmp(argv[i], "-V") || !strcmp(argv[i], "--version")) {
        version();
        return 1;
      }
      // -----------------------------------------------------//
      else if (!strcmp(argv[i], "-v") || !strcmp(argv[i], "--verbose")) {
        std::string vLevStr(argv[++i]);
        if (vLevStr == "error")
          vLevel = GGSSmartLog::ERROR;
        else if (vLevStr == "warning")
          vLevel = GGSSmartLog::WARNING;
        else if (vLevStr == "normal" || vLevStr == "info")
          vLevel = GGSSmartLog::INFO;
        else if (vLevStr == "debug")
          vLevel = GGSSmartLog::DEBUG;
        else if (vLevStr == "deepdeb")
          vLevel = GGSSmartLog::DEEPDEB;
        else {
          GGSCOUT(WARNING) << "Unrecognized verbosity level: " << vLevStr << ". Ignoring." << GGSENDL;
        }
      }
      // -----------------------------------------------------//
      else if (!strcmp(argv[i], "-o") || !strcmp(argv[i], "--output-file")) {
        if (++i >= argc) {
          usage();
          return 1;
        }
        outputFile = argv[i];
      }
      // -----------------------------------------------------//
      else if (!strcmp(argv[i], "-t") || !strcmp(argv[i], "--output-type")) {
        if (++i >= argc) {
          usage();
          return 1;
        }
        if (strcmp(argv[i], "g4.gdml") && strcmp(argv[i], "tgeo.root") && strcmp(argv[i], "tgeo.gdml")) {
          GGSCOUT(ERROR) << "Unknown output type: " << argv[i] << GGSENDL;
          return 1;
        }
#ifndef USE_G4GDML
        if (!strcmp(argv[i], "g4.gdml")) {
          GGSCOUT(ERROR) << "Converting to gdml requires Geant4 version compiled with Xerces-C" << GGSENDL;
          return 1;
        }
#endif
#ifndef USE_TGEOROOT
        if (!strcmp(argv[i], "tgeo.root")) {
          GGSCOUT(ERROR) << "Converting to TGeo requires Virtual Geometry Model" << GGSENDL;
          return 1;
        }
#endif
#ifndef USE_TGEOGDML
        if (!strcmp(argv[i], "tgeo.gdml")) {
          GGSCOUT(ERROR)
              << "Converting to gdml via TGeo requires Virtual Geometry Model and Root > 6.22.06 compiled with "
                 "GDML support"
              << GGSENDL;
          return 1;
        }
#endif

        outputType = argv[i];
      }
      // -----------------------------------------------------//
      else if (!strcmp(argv[i], "-g") || !strcmp(argv[i], "--geometry")) {
        if (++i >= argc) {
          usage();
          return 1;
        }
        geometryFile = argv[i];
      }
      // -----------------------------------------------------//
      else if (!strcmp(argv[i], "-gd") || !strcmp(argv[i], "--geo-data-card")) {
        if (++i >= argc) {
          usage();
          return 1;
        }
        geoDataCard = argv[i];
      }
      // -----------------------------------------------------//
      else if (!strcmp(argv[i], "-u") || !strcmp(argv[i], "--gdml-schema-location")) {
        if (++i >= argc) {
          usage();
          return 1;
        }
        schemaLocation = argv[i];
      }
      // -----------------------------------------------------//
      else {
        GGSCOUT(WARNING) << "Unidentified input argument \"" << argv[i] << "\". Ignoring." << GGSENDL;
      }
      i++;
    }
  }

  GGSSmartLog::verboseLevel = vLevel;
  return 0;
}

int main(int argc, const char **argv) {
  static const std::string routineName("GGSWolowitz");

  if (HandleInputPar(argc, argv))
    return 0;

  version();

  GGSCOUT(DEBUG) << "Start run manager " << GGSENDL;
  G4RunManager *runManager = new G4RunManager();

  if (!(GGSGeoPluginManager::GetInstance().LoadGeoPlugin(geometryFile))) {
    GGSCOUT(ERROR) << "Impossible to load geometry library " << geometryFile << ". Exit." << GGSENDL;
    delete runManager;
    return 1;
  }

  GGSVGeometryConstruction *geometry = GGSGeoPluginManager::GetInstance().GetGeoConstruction();
  if (!geometry) {
    GGSCOUT(ERROR) << "Can't create the geometry. Exit." << GGSENDL;
    delete runManager;
    return 1;
  }
  // runManager->SetUserInitialization(geometry);

  GGSCOUT(DEBUG) << "Construct the geometry." << GGSENDL;

  geometry->SetGeoDataCard(geoDataCard);
  G4VPhysicalVolume *physVolume = geometry->Construct();

#ifdef USE_G4GDML
  if (GGSWolowitz::outputType == "g4.gdml") {
    GGSCOUT(DEBUG) << "Write the GDML file using G4GDMLParser." << GGSENDL;
    G4GDMLParser parser;
    parser.SetAddPointerToName(true);
    if (outputFile.length() < 6 || outputFile.substr(outputFile.length() - 8) != ".g4.gdml") {
      GGSCOUT(DEBUG) << "Append .g4.gdml extension to output file name" << GGSENDL;
      outputFile.append(".g4.gdml");
    }
    parser.Write(outputFile, physVolume, true, schemaLocation);
  }
#endif
#if defined(USE_TGEOROOT) || defined(USE_TGEOGDML)
  if (GGSWolowitz::outputType == "tgeo.root" || GGSWolowitz::outputType == "tgeo.gdml") {
    GGSCOUT(DEBUG) << "Write the " << (GGSWolowitz::outputType == "tgeo.root" ? "VGM" : "TGEO GDML") << " file."
                   << GGSENDL;
    Geant4GM::Factory *g4Factory = new Geant4GM::Factory();
    if (GGSSmartLog::verboseLevel >= GGSSmartLog::DEBUG)
      g4Factory->SetDebug(1);
    g4Factory->Import(physVolume);

    // Export VGM geometry to Root
    RootGM::Factory *rtFactory = new RootGM::Factory();
    if (GGSSmartLog::verboseLevel >= GGSSmartLog::DEBUG)
      rtFactory->SetDebug(1);
    g4Factory->Export(rtFactory);
    gGeoManager->CloseGeometry();

#ifdef USE_TGEOROOT
    if (GGSWolowitz::outputType == "tgeo.root") {
      if (outputFile.length() < 6 || outputFile.substr(outputFile.length() - 10) != ".tgeo.root") {
        GGSCOUT(DEBUG) << "Append .tgeo.root extension to output file name" << GGSENDL;
        outputFile.append(".tgeo.root");
      }
    }
#endif
#ifdef USE_TGEOGDML
    if (GGSWolowitz::outputType == "tgeo.gdml") {
      if (outputFile.length() < 11 || outputFile.substr(outputFile.length() - 10) != ".tgeo.gdml") {
        GGSCOUT(DEBUG) << "Append .tgeo.gdml extension to output file name" << GGSENDL;
        outputFile.append(".tgeo.gdml");
      }
      TGeoManager::LockDefaultUnits(kFALSE);
      TGeoManager::SetDefaultUnits(TGeoManager::EDefaultUnits::kRootUnits);
    }
#endif

    gGeoManager->Export(outputFile.data());
  }
#endif

  return 0;
}