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_GDML
#include "G4GDMLParser.hh"
#endif
#include "G4RunManager.hh"
#include "G4TransportationManager.hh"

// VGM headers
#ifdef USE_VGM
#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/GGSInputParser.h"
#include "utils/GGSSmartLog.h"

namespace GGSWolowitz {
G4String outputFile = "GGSGeometry";
G4String geoDataCard = "";
G4String geometryFile = "";
#ifdef USE_GDML
G4String outputType = "gdml";
#else
G4String outputType = "vgm";
#endif
G4String inputFile = "";
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_GDML
               "GDML"
#ifdef USE_VGM
               " and "
#endif
#endif
#ifdef USE_VGM
               "VGM"
#endif
               ".\n";
  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_GDML
               "gdml, "
#endif
#ifdef USE_VGM
               "vgm, "
#endif
               "default: "
            << GGSWolowitz::outputType << ")\n";
  std::cout << " -i, --input-file FILE       file containing input arguments [default: not set]\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";
  std::cout << "\nFor bug reporting instructions, please see for example:\n";
  std::cout << "     <http://www.ts.infn.it/~mocchiut/bugs/bugs.html>.\n";
  std::cout << "Report bugs to: mori@fi.infn.it" << std::endl;
}

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 {
          COUT(WARNING) << "Unrecognized verbosity level: " << vLevStr << ". Ignoring." << ENDL;
        }
      }
      // -----------------------------------------------------//
      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], "gdml") && strcmp(argv[i], "vgm")) {
          COUT(ERROR) << "Unknown output type: " << argv[i] << ENDL;
          return 1;
        }
#ifndef USE_GDML
        if (!strcmp(argv[i], "gdml")) {
          COUT(ERROR) << "Converting to gdml requires Geant4 version compiled with Xerces-C" << ENDL;
          return 1;
        }
#endif
#ifndef USE_VGM
        if (!strcmp(argv[i], "vgm")) {
          COUT(ERROR) << "Converting to vgm requires Virtual Geometry Model" << ENDL;
          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], "-i") || !strcmp(argv[i], "--input-file")) {
        if (++i >= argc) {
          usage();
          return 1;
        }
        inputFile = argv[i];
      }
      // -----------------------------------------------------//
      else if (!strcmp(argv[i], "-u") || !strcmp(argv[i], "--gdml-schema-location")) {
        if (++i >= argc) {
          usage();
          return 1;
        }
        schemaLocation = argv[i];
      }
      // -----------------------------------------------------//
      else {
        COUT(WARNING) << "Unidentified input argument \"" << argv[i] << "\". Ignoring." << ENDL;
      }
      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();

  if (strcmp(inputFile.c_str(), "")) {
    int nPar = 0;
    std::string mych[1000];
    GGSInputParser::GetInstance().ReadInput(inputFile, &nPar, (std::string *)mych);
    if (nPar > 1) {
      const char **fileArgv;
      fileArgv = new const char *[nPar];
      int i = 0;
      while (i < nPar) {
        fileArgv[i] = (mych[i]).c_str();
        i++;
      }
      if (HandleInputPar(nPar, fileArgv))
        return 0;
    }
  }

  COUT(DEBUG) << "Start run manager " << ENDL;
  G4RunManager *runManager = new G4RunManager();

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

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

  COUT(DEBUG) << "Construct the geometry." << ENDL;

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

#ifdef USE_GDML
  if (GGSWolowitz::outputType == "gdml") {
    COUT(DEBUG) << "Write the GDML file." << ENDL;
    G4GDMLParser parser;
    parser.SetAddPointerToName(true);
    if (outputFile.length() < 6 || outputFile.substr(outputFile.length() - 5) != ".gdml") {
      COUT(DEBUG) << "Append .gdml extension to output file name" << ENDL;
      outputFile.append(".gdml");
    }
    parser.Write(outputFile, physVolume, true, schemaLocation);
  }
#endif
#ifdef USE_VGM
  if (GGSWolowitz::outputType == "vgm") {
    COUT(DEBUG) << "Write the VGM file." << ENDL;
    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();
    if (outputFile.length() < 6 || outputFile.substr(outputFile.length() - 5) != ".root") {
      COUT(DEBUG) << "Append .root extension to output file name" << ENDL;
      outputFile.append(".root");
    }
    gGeoManager->Export(outputFile.data());
  }
#endif

  return 0;
}