#include <cassert>
#include <cstdlib>
#include <string>
#include <vector>
#include <TSystem.h>
#include "Framework/Conventions/GBuild.h"
#include "Framework/EventGen/GEVGDriver.h"
#include "Framework/Interaction/Interaction.h"
#include "Framework/Messenger/Messenger.h"
#include "Framework/Numerical/RandomGen.h"
#include "Framework/ParticleData/PDGCodeList.h"
#include "Framework/Utils/RunOpt.h"
#include "Framework/Utils/AppInit.h"
#include "Framework/Utils/StringUtils.h"
#include "Framework/Utils/PrintUtils.h"
#include "Framework/Utils/XSecSplineList.h"
#include "Framework/Utils/CmdLnArgParser.h"

Include dependency graph for gMakeSplines.cxx:

Functions
void	GetCommandLineArgs (int argc, char **argv)
void	PrintSyntax (void)
PDGCodeList *	GetNeutrinoCodes (void)
PDGCodeList *	GetTargetCodes (void)
int	main (int argc, char **argv)

Variables
string	gOptNuPdgCodeList = ""
string	gOptTgtPdgCodeList = ""
string	gOptGeomFilename = ""
int	gOptNKnots = -1
double	gOptMaxE = -1.
bool	gOptNoCopy = false
long int	gOptRanSeed = -1
string	gOptInpXSecFile = ""
string	gOptOutXSecFile = ""

Function Documentation

◆ GetCommandLineArgs()

void GetCommandLineArgs	(	int	argc,
		char **	argv )

Definition at line 214 of file gMakeSplines.cxx.

{
  LOG("gmkspl", pINFO) << "Parsing command line arguments";
 
  // Common run options. Set defaults and read.
  RunOpt::Instance()->EnableBareXSecPreCalc(true);
  RunOpt::Instance()->ReadFromCommandLine(argc,argv);
 
  // Parse run options for this app
 
  CmdLnArgParser parser(argc,argv);
 
  // output XML file name
  if( parser.OptionExists('o') ||
      parser.OptionExists("output-cross-sections") )
  {
    LOG("gmkspl", pINFO) << "Reading output filename";
    if( parser.OptionExists('o') ) {
      gOptOutXSecFile = parser.ArgAsString('o');
    }
    else {
      gOptOutXSecFile = parser.ArgAsString("output-cross-sections");
    }
  } else {
    LOG("gmkspl", pINFO) << "Unspecified filename - Using default";
    gOptOutXSecFile = "xsec_splines.xml";
  }
 
  // number of knots
  if( parser.OptionExists('n') ) {
    LOG("gmkspl", pINFO) << "Reading number of knots/spline";
    gOptNKnots = parser.ArgAsInt('n');
  } else {
    LOG("gmkspl", pINFO)
      << "Unspecified number of knots - Using default";
    gOptNKnots = -1;
  }
 
  // max spline energy (if < max of validity range)
  if( parser.OptionExists('e') ) {
    LOG("gmkspl", pINFO) << "Reading maximum spline energy";
    gOptMaxE = parser.ArgAsDouble('e');
  } else {
    LOG("gmkspl", pINFO)
       << "Unspecified maximum spline energy - Using default";
    gOptMaxE = -1;
  }
 
  // write out input splines?
  if( parser.OptionExists("no-copy") ) {
    LOG("gmkspl", pINFO) << "Not copying input splines to output";
    gOptNoCopy = true;
  }
 
  // comma-separated neutrino PDG code list
  if( parser.OptionExists('p') ) {
    LOG("gmkspl", pINFO) << "Reading neutrino PDG codes";
    gOptNuPdgCodeList = parser.ArgAsString('p');
  } else {
    LOG("gmkspl", pFATAL)
       << "Unspecified neutrino PDG code list - Exiting";
    PrintSyntax();
    exit(1);
  }
 
  // comma-separated target PDG code list or input geometry file
  bool tgt_cmd = true;
  if( parser.OptionExists('t') ) {
    LOG("gmkspl", pINFO) << "Reading target nuclei PDG codes";
    gOptTgtPdgCodeList = parser.ArgAsString('t');
  } else {
    LOG("gmkspl", pINFO) << "No code list specified from the command line";
    tgt_cmd = false;
  }
 
  bool tgt_geom = true;
  if( parser.OptionExists('f') ) {
    LOG("gmkspl", pINFO) << "Reading ROOT geometry filename";
    gOptGeomFilename = parser.ArgAsString('f');
  } else {
    LOG("gmkspl", pINFO) << "No geometry file was specified";
    tgt_cmd = false;
  }
 
  bool both =  tgt_geom &&  tgt_cmd;
  bool none = !tgt_geom && !tgt_cmd;
  if(none) {
    LOG("gmkspl", pFATAL)
          << "No geom file or cmd line target list was specified - Exiting";
    PrintSyntax();
    exit(1);
  }
  if(both) {
    LOG("gmkspl", pFATAL)
       << "You specified both a geom file and a cmd line target list "
         << "- Exiting confused";
    PrintSyntax();
    exit(1);
  }
 
  // random number seed
  if( parser.OptionExists("seed") ) {
    LOG("gmkspl", pINFO) << "Reading random number seed";
    gOptRanSeed = parser.ArgAsLong("seed");
  } else {
    LOG("gmkspl", pINFO) << "Unspecified random number seed - Using default";
    gOptRanSeed = -1;
  }
 
  // input cross-section file
  if( parser.OptionExists("input-cross-sections") ) {
    LOG("gmkspl", pINFO) << "Reading cross-section file";
    gOptInpXSecFile = parser.ArgAsString("input-cross-sections");
  } else {
    LOG("gmkspl", pINFO) << "Unspecified input cross-section file";
    gOptInpXSecFile = "";
  }
 
  //
  // print the command-line options
  //
  LOG("gmkspl", pNOTICE)
     << "\n"
     << utils::print::PrintFramedMesg("gmkspl job configuration")
     << "\n Neutrino PDG codes : " << gOptNuPdgCodeList
     << "\n Target PDG codes : " << gOptTgtPdgCodeList
     << "\n Input ROOT geometry : " << gOptGeomFilename
     << "\n Output cross-section file : " << gOptOutXSecFile
     << "\n Input cross-section file : " << gOptInpXSecFile
     << "\n Random number seed : " << gOptRanSeed
     << "\n";
 
  LOG("gmkspl", pNOTICE) << *RunOpt::Instance();
}

References genie::CmdLnArgParser::ArgAsDouble(), genie::CmdLnArgParser::ArgAsInt(), genie::CmdLnArgParser::ArgAsLong(), genie::CmdLnArgParser::ArgAsString(), genie::RunOpt::EnableBareXSecPreCalc(), gOptGeomFilename, gOptInpXSecFile, gOptMaxE, gOptNKnots, gOptNoCopy, gOptNuPdgCodeList, gOptOutXSecFile, gOptRanSeed, gOptTgtPdgCodeList, genie::RunOpt::Instance(), LOG, genie::CmdLnArgParser::OptionExists(), pFATAL, pINFO, pNOTICE, genie::utils::print::PrintFramedMesg(), PrintSyntax(), and genie::RunOpt::ReadFromCommandLine().

Referenced by main().

◆ GetNeutrinoCodes()

PDGCodeList * GetNeutrinoCodes ( void )

Definition at line 366 of file gMakeSplines.cxx.

{
  // split the comma separated list
  vector<string> nuvec = utils::str::Split(gOptNuPdgCodeList,  ",");
 
  // fill in the PDG code list
  PDGCodeList * list = new PDGCodeList;
  vector<string>::const_iterator iter;
  for(iter = nuvec.begin(); iter != nuvec.end(); ++iter) {
    list->push_back( atoi(iter->c_str()) );
  }
  return list;
}

References gOptNuPdgCodeList, genie::PDGCodeList::push_back(), and genie::utils::str::Split().

Referenced by main().

◆ GetTargetCodes()

PDGCodeList * GetTargetCodes ( void )

Definition at line 380 of file gMakeSplines.cxx.

{
  bool from_geom_file = ( gOptGeomFilename.size()   > 0 );
  bool from_cmd_line  = ( gOptTgtPdgCodeList.size() > 0 );
 
  if (from_cmd_line) {
     // split the comma separated list
     vector<string> tgtvec = utils::str::Split(gOptTgtPdgCodeList, ",");
 
     // fill in the PDG code list
     PDGCodeList * list = new PDGCodeList;
     vector<string>::const_iterator iter;
     for(iter = tgtvec.begin(); iter != tgtvec.end(); ++iter) {
        list->push_back( atoi(iter->c_str()) );
     }
     return list;
  }
 
  if (from_geom_file) {
#ifdef __GENIE_GEOM_DRIVERS_ENABLED__
     // create/configure a geometry driver
     LOG("gmkspl", pINFO) << "Creating/configuring a ROOT geom. driver";
     ROOTGeomAnalyzer * geom = new ROOTGeomAnalyzer(gOptGeomFilename);
 
     PDGCodeList * list = new PDGCodeList(geom->ListOfTargetNuclei());
 
     delete geom;
     return list;
#else
     LOG("gmkspl", pFATAL)
      << "To read-in a ROOT geometry you need to enable the geometry drivers!";
     gAbortingInErr = true;
     exit(1);
     return 0;
#endif
 
  }
  return 0;
}

References genie::gAbortingInErr, geom, gOptGeomFilename, gOptTgtPdgCodeList, LOG, pFATAL, pINFO, genie::PDGCodeList::push_back(), and genie::utils::str::Split().

Referenced by main().

◆ main()

int main	(	int	argc,
		char **	argv )

Definition at line 145 of file gMakeSplines.cxx.

{
  // Parse command line arguments
  GetCommandLineArgs(argc,argv);
 
  if ( ! RunOpt::Instance()->Tune() ) {
    LOG("gmkspl", pFATAL) << " No TuneId in RunOption";
    exit(-1);
  }
  RunOpt::Instance()->BuildTune();
 
  // throw on NaNs and Infs...
#if defined(HAVE_FENV_H) && defined(HAVE_FEENABLEEXCEPT)
  feenableexcept(FE_DIVBYZERO | FE_INVALID | FE_OVERFLOW);
#endif
 
  // Init
  utils::app_init::MesgThresholds(RunOpt::Instance()->MesgThresholdFiles());
  utils::app_init::RandGen(gOptRanSeed);
  utils::app_init::XSecTable(gOptInpXSecFile, false);
 
  // Get list of neutrinos and nuclear targets
 
  PDGCodeList * neutrinos = GetNeutrinoCodes();
  PDGCodeList * targets   = GetTargetCodes();
 
  if(!neutrinos || neutrinos->size() == 0 ) {
     LOG("gmkspl", pFATAL) << "Empty neutrino PDG code list";
     PrintSyntax();
     exit(2);
  }
  if(!targets || targets->size() == 0 ) {
     LOG("gmkspl", pFATAL) << "Empty target PDG code list";
     PrintSyntax();
     exit(3);
  }
 
  LOG("gmkspl", pINFO) << "Neutrinos: " << *neutrinos;
  LOG("gmkspl", pINFO) << "Targets: "   << *targets;
 
  // Loop over all possible input init states and ask the GEVGDriver
  // to build splines for all the interactions that its loaded list
  // of event generators can generate.
 
  PDGCodeList::const_iterator nuiter;
  PDGCodeList::const_iterator tgtiter;
  for(nuiter = neutrinos->begin(); nuiter != neutrinos->end(); ++nuiter) {
    for(tgtiter = targets->begin(); tgtiter != targets->end(); ++tgtiter) {
      int nupdgc  = *nuiter;
      int tgtpdgc = *tgtiter;
      InitialState init_state(tgtpdgc, nupdgc);
      GEVGDriver driver;
      driver.SetEventGeneratorList(RunOpt::Instance()->EventGeneratorList());
      driver.Configure(init_state);
      driver.CreateSplines(gOptNKnots, gOptMaxE);
    }
  }
 
  // Save the splines at the requested XML file
  XSecSplineList * xspl = XSecSplineList::Instance();
  bool save_init = !gOptNoCopy;
  xspl->SaveAsXml(gOptOutXSecFile, save_init);
 
  delete neutrinos;
  delete targets;
 
  return 0;
}

References genie::RunOpt::BuildTune(), genie::GEVGDriver::Configure(), genie::GEVGDriver::CreateSplines(), GetCommandLineArgs(), GetNeutrinoCodes(), GetTargetCodes(), gOptInpXSecFile, gOptMaxE, gOptNKnots, gOptNoCopy, gOptOutXSecFile, gOptRanSeed, genie::RunOpt::Instance(), genie::XSecSplineList::Instance(), LOG, genie::utils::app_init::MesgThresholds(), pFATAL, pINFO, PrintSyntax(), genie::utils::app_init::RandGen(), genie::XSecSplineList::SaveAsXml(), genie::GEVGDriver::SetEventGeneratorList(), and genie::utils::app_init::XSecTable().

◆ PrintSyntax()

void PrintSyntax ( void )

Definition at line 349 of file gMakeSplines.cxx.

{
  LOG("gmkspl", pNOTICE)
    << "\n\n" << "Syntax:" << "\n"
    << "   gmkspl -p nupdg"
    << "\n    <-t tgtpdg, -f geomfile> "
    << "\n    <-o | --output-cross-sections> xsec_xml_file_name"
    << "\n    [-n nknots]"
    << "\n    [-e max_energy]"
    << "\n    [--no-copy]"
    << "\n    [--seed seed_number]"
    << "\n    [--input-cross-sections xml_file]"
    << RunOpt::RunOptSyntaxString(false)
    << "\n";
 
}