genie::XSecSplineList Class Reference

List of cross section vs energy splines. More...

#include <XSecSplineList.h>

Collaboration diagram for genie::XSecSplineList:

Classes
struct	Cleaner

Public Member Functions
void	SaveAsXml (const string &filename, bool save_init=true) const
XmlParserStatus_t	LoadFromXml (const string &filename, bool keep=false)
void	Print (ostream &stream) const
void	SetCurrentTune (const string &tune)
string	CurrentTune (void) const
bool	HasSplineFromTune (const string &tune) const
bool	SplineExists (const XSecAlgorithmI *alg, const Interaction *i) const
bool	SplineExists (string spline_key) const
const Spline *	GetSpline (const XSecAlgorithmI *alg, const Interaction *i) const
const Spline *	GetSpline (string spline_key) const
void	CreateSpline (const XSecAlgorithmI *alg, const Interaction *i, int nknots=-1, double e_min=-1, double e_max=-1)
int	NSplines (void) const
bool	IsEmpty (void) const
string	BuildSplineKey (const XSecAlgorithmI *alg, const Interaction *i) const
const vector< string > *	GetSplineKeys (void) const
void	SetLogE (bool on)
	set opt to build splines as f(E) or as f(logE)
void	SetNKnots (int nk)
	set default number of knots for building the spline
void	SetMinE (double Ev)
	set default minimum energy for xsec splines
void	SetMaxE (double Ev)
	set default maximum energy for xsec splines
bool	UseLogE (void) const
int	NKnots (void) const
double	Emin (void) const
double	Emax (void) const

Static Public Member Functions
static XSecSplineList *	Instance ()

Private Member Functions
	XSecSplineList ()
	XSecSplineList (const XSecSplineList &spline_list)
virtual	~XSecSplineList ()

Private Attributes
bool	fUseLogE
int	fNKnots
double	fEmin
double	fEmax
string	fCurrentTune
	The ‘active’ tune, out the many that can co-exist.
map< string, map< string, Spline * > >	fSplineMap
	tune -> { xsec_alg/xsec_config/interaction -> Spline }
map< string, set< string > >	fLoadedSplineSet
	tune -> { set of initialy loaded splines }

Static Private Attributes
static XSecSplineList *	fInstance = 0

Friends
struct	Cleaner
ostream &	operator<< (ostream &stream, const XSecSplineList &xsl)

Detailed Description

List of cross section vs energy splines.

Author

Costas Andreopoulos <c.andreopoulos \at cern.ch> University of Liverpool

Created:\n May 12, 2005

License:\n Copyright (c) 2003-2025, The GENIE Collaboration

For the full text of the license visit http://copyright.genie-mc.org

Definition at line 45 of file XSecSplineList.h.

Constructor & Destructor Documentation

XSecSplineList() [1/2]

genie::XSecSplineList::XSecSplineList ( )

private

Definition at line 52 of file XSecSplineList.cxx.

{
  fInstance    =  0;
  fCurrentTune = "";
  fUseLogE     = true;
  fNKnots      = 100;
  fEmin        =   0.01; // GeV
  fEmax        = 100.00; // GeV
}

References fCurrentTune, fEmax, fEmin, fInstance, fNKnots, and fUseLogE.

Referenced by Instance(), operator<<, and XSecSplineList().

XSecSplineList() [2/2]

genie::XSecSplineList::XSecSplineList ( const XSecSplineList & spline_list )

private

References XSecSplineList().

~XSecSplineList()

genie::XSecSplineList::~XSecSplineList ( )

privatevirtual

Definition at line 62 of file XSecSplineList.cxx.

{
// Clean up.
 
  map<string,  map<string, Spline *> >::iterator mm_iter = fSplineMap.begin();
  for( ; mm_iter != fSplineMap.end(); ++mm_iter) {
    // loop over splines for given tune
    map<string, Spline *> & spl_map_curr_tune = mm_iter->second;
    map<string, Spline *>::iterator m_iter = spl_map_curr_tune.begin();
    for( ; m_iter != spl_map_curr_tune.end(); ++m_iter) {
      Spline * spline = m_iter->second;
      delete spline;
      spline = 0;
    }
    spl_map_curr_tune.clear();
  }
  fSplineMap.clear();
  fInstance = 0;
}

References fInstance, and fSplineMap.

Member Function Documentation

BuildSplineKey()

string genie::XSecSplineList::BuildSplineKey	(	const XSecAlgorithmI *	alg,
		const Interaction *	i ) const

Definition at line 539 of file XSecSplineList.cxx.

{
  if(!alg) {
    LOG("XSecSplLst", pWARN)
            << "Null XSecAlgorithmI - Returning empty spline key";
    return "";
  }
 
  if(!interaction) {
    LOG("XSecSplLst", pWARN)
            << "Null Interaction - Returning empty spline key";
    return "";
  }
 
  string alg_name  = alg->Id().Name();
  string param_set = alg->Id().Config();
  string intkey    = interaction->AsString();
 
  string key = alg_name + "/" + param_set + "/" + intkey;
 
  return key;
}

References genie::Interaction::AsString(), genie::AlgId::Config(), genie::Algorithm::Id(), LOG, genie::AlgId::Name(), and pWARN.

Referenced by CreateSpline(), GetSpline(), and SplineExists().

CreateSpline()

void genie::XSecSplineList::CreateSpline	(	const XSecAlgorithmI *	alg,
		const Interaction *	i,
		int	nknots = -1,
		double	e_min = -1,
		double	e_max = -1 )

Definition at line 160 of file XSecSplineList.cxx.

{
// Build a cross section spline for the input interaction using the input
// cross section algorithm and store in the list.
// For building this specific entry of the spline list, the user is allowed
// to override the list-wide nknots,e_min,e_max
 
  // FE_ALL_EXCEPT FE_INEXACT FE_UNDERFLOW
  // FE_DIVBYZERO  FE_INVALID FE_OVERFLO
  // rwh -- uncomment to catch NaN
  // feenableexcept(FE_DIVBYZERO|FE_INVALID|FE_OVERFLOW);
 
 
  SLOG("XSecSplLst", pNOTICE)
     << "Creating cross section spline using the algorithm: " << *alg;
 
  string key = this->BuildSplineKey(alg,interaction);
 
  // If any of the nknots,e_min,e_max was not set or its value is not acceptable
  // use the list values
  //
  if (e_min   < 0.) e_min = this->Emin();
  if (e_max   < 0.) e_max = this->Emax();
  if (nknots <= 2) nknots = this->NKnots();
  assert( e_min < e_max );
 
  std::vector<double> xsec( nknots, 0. ) ;
  std::vector<double> E( nknots, 0. ) ;
 
  // Distribute the knots in the energy range (e_min,e_max) :
  // - Will use 5 knots linearly spaced below the energy thresholds so that the
  //   spline behaves correctly in (e_min,Ethr)
  // - Place 1 knot exactly on the input interaction threshold
  // - Place the remaining n-6 knots spaced either linearly or logarithmically
  //   above the input interaction threshold
  // The above scheme schanges appropriately if Ethr<e_min (i.e. no knots
  // are computed below threshold)
  //
  double Ethr = interaction->PhaseSpace().Threshold();
  SLOG("XSecSplLst", pNOTICE)
    << "Energy threshold for current interaction = " << Ethr << " GeV";
 
  if (Ethr>e_max) {
    SLOG("XSecSplLst", pFATAL) << "Energy threshold higher than maximum.";
    SLOG("XSecSplLst", pFATAL) << "Energy threshold = " << Ethr << " GeV";
    SLOG("XSecSplLst", pFATAL) << "Energy maximum = " << e_max << " GeV";
    return;
  }
 
  int nkb = (Ethr>e_min) ? 5 : 0; // number of knots <  threshold
  int nka = nknots-nkb;           // number of knots >= threshold
 
  // knots < energy threshold
  double dEb =  (Ethr>e_min) ? (Ethr - e_min) / nkb : 0;
  for(int i=0; i<nkb; i++) {
     E[i] = e_min + i*dEb;
  }
  // knots >= energy threshold
  double E0  = TMath::Max(Ethr,e_min);
  double dEa = 0;
  if(this->UseLogE())
    dEa = (TMath::Log10(e_max) - TMath::Log10(E0)) /(nka-1);
  else
    dEa = (e_max-E0) /(nka-1);
 
  for(int i=0; i<nka; i++) {
     if(this->UseLogE())
       E[i+nkb] = TMath::Power(10., TMath::Log10(E0) + i * dEa);
     else
       E[i+nkb] = E0 + i * dEa;
  }
  // force last point to avoid floating point cumulative slew
  E[nknots-1] = e_max;
 
  // Compute cross sections for the input interaction at the selected
  // set of energies
  //
  double pr_mass = interaction->InitStatePtr()->Probe()->Mass();
  for (int i = 0; i < nknots; i++) {
    TLorentzVector p4(0,0,E[i],E[i]);
    if (pr_mass > 0.) {
      double pz = TMath::Max(0.,E[i]*E[i] - pr_mass*pr_mass);
      pz = TMath::Sqrt(pz);
      p4.SetPz(pz);
    }
    interaction->InitStatePtr()->SetProbeP4(p4);
 
    steady_clock::time_point start = steady_clock::now();
 
    xsec[i] = alg->Integral(interaction);
 
    steady_clock::time_point end = steady_clock::now();
 
    duration<double> time_span = duration_cast<duration<double>>(end - start);
 
    SLOG("XSecSplLst", pNOTICE)
                       << "xsec(E = " << E[i] << ") =  "
                       << (1E+38/units::cm2)*xsec[i] << " x 1E-38 cm^2, evaluated in " << time_span.count() << " s";
    if ( std::isnan(xsec[i]) ) {
      // this sometimes happens near threshold, warn and move on
      SLOG("XSecSplLst", pWARN)
                       << "xsec(E = " << E[i] << ") =  "
                       << (1E+38/units::cm2)*xsec[i] << " x 1E-38 cm^2"
                       << " : converting NaN to 0.0";
      xsec[i] = 0.0;
    }
 
  }
 
  // Warn about odd case of decreasing cross section
  //    but allow for small variation due to integration errors
  const double eps_xsec = 1.0e-5;
  const double xsec_scale = (1.0-eps_xsec);
  if ( xsec[nknots-1] < xsec[nknots-2]*xsec_scale ) {
    SLOG("XSecSplLst", pWARN)
      << "Last point oddity: " << key <<  " has "
      << " xsec[nknots-1] " << xsec[nknots-1] << " < "
      << " xsec[nknots-2] " << xsec[nknots-2];
  }
 
  // Build
  //
  Spline * spline = new Spline(nknots, E.data(), xsec.data());
 
  // Save
  //
  map<string,  map<string, Spline *> >::iterator //\/
  mm_iter = fSplineMap.find(fCurrentTune);
  if(mm_iter == fSplineMap.end()) {
    map<string, Spline *> spl_map_curr_tune;
    fSplineMap.insert( map<string, map<string, Spline *> >::value_type(
      fCurrentTune, spl_map_curr_tune) );
    mm_iter = fSplineMap.find(fCurrentTune);
  }
  map<string, Spline *> & spl_map_curr_tune = mm_iter->second;
  spl_map_curr_tune.insert( map<string, Spline *>::value_type(key, spline) );
}

References BuildSplineKey(), genie::units::cm2, Emax(), Emin(), fCurrentTune, fSplineMap, genie::Interaction::InitStatePtr(), genie::XSecAlgorithmI::Integral(), NKnots(), pFATAL, genie::Interaction::PhaseSpace(), pNOTICE, genie::InitialState::Probe(), pWARN, genie::InitialState::SetProbeP4(), SLOG, genie::KPhaseSpace::Threshold(), and UseLogE().

Referenced by genie::GEVGDriver::CreateSplines().

CurrentTune()

string genie::XSecSplineList::CurrentTune ( void ) const

inline

Definition at line 63 of file XSecSplineList.h.

{ return fCurrentTune; }

References fCurrentTune.

Emax()

double genie::XSecSplineList::Emax ( void ) const

inline

Definition at line 91 of file XSecSplineList.h.

{ return fEmax;     }

References fEmax.

Referenced by CreateSpline().

Emin()

double genie::XSecSplineList::Emin ( void ) const

inline

Definition at line 90 of file XSecSplineList.h.

{ return fEmin;     }

References fEmin.

Referenced by CreateSpline().

GetSpline() [1/2]

const Spline * genie::XSecSplineList::GetSpline	(	const XSecAlgorithmI *	alg,
		const Interaction *	i ) const

Definition at line 124 of file XSecSplineList.cxx.

{
  string key = this->BuildSplineKey(alg,interaction);
  return this->GetSpline(key);
}

References BuildSplineKey(), and GetSpline().

Referenced by GetSpline(), genie::AlamSimoAtharVacasSKXSec::Integrate(), genie::DISXSec::Integrate(), genie::DMDISXSec::Integrate(), genie::HEDISXSec::Integrate(), genie::HELeptonXSec::Integrate(), genie::ReinSehgalRESXSec::Integrate(), genie::ReinSehgalRESXSecFast::Integrate(), genie::SPPXSec::Integrate(), genie::PhysInteractionSelector::SelectInteraction(), genie::GEVGDriver::XSecSpline(), and genie::GEVGDriver::XSecSum().

GetSpline() [2/2]

const Spline * genie::XSecSplineList::GetSpline

(

string

spline_key

)

const

Definition at line 131 of file XSecSplineList.cxx.

{
 
  if ( fCurrentTune.size() == 0 ) {
    SLOG("XSecSplLst", pFATAL) << "Spline requested while CurrentTune not set" ;
    exit(0) ;
  }
 
  SLOG("XSecSplLst", pDEBUG)
    << "Getting spline: " << key << " in tune: " << fCurrentTune;
 
  map<string,  map<string, Spline *> >::const_iterator //\/
  mm_iter = fSplineMap.find(fCurrentTune);
  if(mm_iter == fSplineMap.end()) {
    SLOG("XSecSplLst", pWARN)
       << "No splines for tune " << fCurrentTune << " were found!";
    return 0;
  }
  const map<string, Spline *> & spl_map_curr_tune = mm_iter->second;
  map<string, Spline *>::const_iterator //\/
  m_iter = spl_map_curr_tune.find(key);
  if(m_iter == spl_map_curr_tune.end()) {
    SLOG("XSecSplLst", pWARN)
      << "Couldn't find spline: " << key << " in tune: " << fCurrentTune;
    return 0;
  }
  return m_iter->second;
}

References fCurrentTune, fSplineMap, pDEBUG, pFATAL, pWARN, and SLOG.

GetSplineKeys()

const vector< string > * genie::XSecSplineList::GetSplineKeys

(

void

)

const

Definition at line 563 of file XSecSplineList.cxx.

{
  map<string,  map<string, Spline *> >::const_iterator //\/
  mm_iter = fSplineMap.find(fCurrentTune);
  if(mm_iter == fSplineMap.end()) {
    SLOG("XSecSplLst", pWARN)
       << "No splines for tune " << fCurrentTune << " were found!";
    return 0;
  }
  const map<string, Spline *> & spl_map_curr_tune = mm_iter->second;
  vector<string> * keyv = new vector<string>(spl_map_curr_tune.size());
  unsigned int i=0;
  map<string, Spline *>::const_iterator m_iter = spl_map_curr_tune.begin();
  for( ; m_iter != spl_map_curr_tune.end(); ++m_iter) {
    string key = m_iter->first;
    (*keyv)[i++]=key;
  }
  return keyv;
}

References fCurrentTune, fSplineMap, pWARN, and SLOG.

HasSplineFromTune()

bool genie::XSecSplineList::HasSplineFromTune ( const string & tune ) const

inline

Definition at line 64 of file XSecSplineList.h.

{ return fSplineMap.count(tune) > 0 ; }

References fSplineMap.

Instance()

XSecSplineList * genie::XSecSplineList::Instance ( )

static

Definition at line 82 of file XSecSplineList.cxx.

{
  if(fInstance == 0) {
    static XSecSplineList::Cleaner cleaner;
    cleaner.DummyMethodAndSilentCompiler();
    fInstance = new XSecSplineList;
  }
  return fInstance;
}

References genie::XSecSplineList::Cleaner::DummyMethodAndSilentCompiler(), fInstance, and XSecSplineList().

Referenced by genie::RunOpt::BuildTune(), genie::SPPXSecWithCache::CacheResExcitationXSec(), Configure(), genie::GEVGDriver::CreateSplines(), genie::AlamSimoAtharVacasSKXSec::Integrate(), genie::DISXSec::Integrate(), genie::DMDISXSec::Integrate(), genie::HEDISXSec::Integrate(), genie::HELeptonXSec::Integrate(), genie::ReinSehgalRESXSec::Integrate(), genie::ReinSehgalRESXSecFast::Integrate(), genie::SPPXSec::Integrate(), LoadSplines(), main(), genie::PhysInteractionSelector::SelectInteraction(), genie::GEVGDriver::UseSplines(), genie::GEVGDriver::XSecSpline(), genie::GEVGDriver::XSecSum(), and genie::utils::app_init::XSecTable().

IsEmpty()

bool genie::XSecSplineList::IsEmpty

(

void

)

const

Definition at line 312 of file XSecSplineList.cxx.

{
  int n = this->NSplines();
  return (n == 0);
}

References NSplines().

Referenced by genie::AlamSimoAtharVacasSKXSec::Integrate(), genie::DISXSec::Integrate(), genie::DMDISXSec::Integrate(), genie::HEDISXSec::Integrate(), genie::HELeptonXSec::Integrate(), genie::ReinSehgalRESXSec::Integrate(), genie::ReinSehgalRESXSecFast::Integrate(), and genie::SPPXSec::Integrate().

LoadFromXml()

XmlParserStatus_t genie::XSecSplineList::LoadFromXml	(	const string &	filename,
		bool	keep = false )

Load XSecSplineList from ROOT file. If keep = true, then the loaded splines are added to the existing list. If false, then the existing list is reset before loading the splines.

Definition at line 402 of file XSecSplineList.cxx.

{
//! Load XSecSplineList from ROOT file. If keep = true, then the loaded splines
//! are added to the existing list. If false, then the existing list is reset
//! before loading the splines.
 
  SLOG("XSecSplLst", pNOTICE)
    << "Loading splines from: " << filename;
  SLOG("XSecSplLst", pINFO)
    << "Option to keep pre-existing splines is switched "
    << ( (keep) ? "ON" : "OFF" );
 
  if(!keep) fSplineMap.clear();
 
  const int kNodeTypeStartElement = 1;
  const int kNodeTypeEndElement   = 15;
  const int kKnotX                = 0;
  const int kKnotY                = 1;
 
  xmlTextReaderPtr reader;
 
  int ret = 0, val_type = -1, iknot = 0, nknots = 0;
  double * E = 0, * xsec = 0;
  string spline_name = "";
  string temp_tune ;
 
  reader = xmlNewTextReaderFilename(filename.c_str());
  if (reader != NULL) {
        ret = xmlTextReaderRead(reader);
        while (ret == 1) {
            xmlChar * name  = xmlTextReaderName     (reader);
            xmlChar * value = xmlTextReaderValue    (reader);
            int       type  = xmlTextReaderNodeType (reader);
            int       depth = xmlTextReaderDepth    (reader);
 
            if(depth==0 && type==kNodeTypeStartElement) {
               LOG("XSecSplLst", pDEBUG) << "Root element = " << name;
               if(xmlStrcmp(name, (const xmlChar *) "genie_xsec_spline_list")) {
                   LOG("XSecSplLst", pERROR)
                     << "\nXML doc. has invalid root element! [filename: " << filename << "]";
                   return kXmlInvalidRoot;
               }
 
               xmlChar * xvrs   = xmlTextReaderGetAttribute(reader,(const xmlChar*)"version");
               xmlChar * xinlog = xmlTextReaderGetAttribute(reader,(const xmlChar*)"uselog");
               string svrs      = utils::str::TrimSpaces((const char *)xvrs);
               string sinlog    = utils::str::TrimSpaces((const char *)xinlog);
 
               LOG("XSecSplLst", pNOTICE)
                   << "Input x-section spline XML file format version: " << svrs;
 
               if (atoi(sinlog.c_str()) == 1) this->SetLogE(true);
               else this->SetLogE(false);
 
               xmlFree(xvrs);
               xmlFree(xinlog);
            }
 
            if( (!xmlStrcmp(name, (const xmlChar *) "genie_tune")) && type==kNodeTypeStartElement) {
               xmlChar * xtune = xmlTextReaderGetAttribute(reader,(const xmlChar*)"name");
               temp_tune    = utils::str::TrimSpaces((const char *)xtune);
               SLOG("XSecSplLst", pNOTICE) << "Loading x-section splines for GENIE tune: " << temp_tune;
               xmlFree(xtune);
            }
 
            if( (!xmlStrcmp(name, (const xmlChar *) "spline")) && type==kNodeTypeStartElement) {
               xmlChar * xname = xmlTextReaderGetAttribute(reader,(const xmlChar*)"name");
               xmlChar * xnkn  = xmlTextReaderGetAttribute(reader,(const xmlChar*)"nknots");
               string sname    = utils::str::TrimSpaces((const char *)xname);
               string snkn     = utils::str::TrimSpaces((const char *)xnkn);
 
               spline_name = sname;
               SLOG("XSecSplLst", pNOTICE) << "Loading spline: " << spline_name;
 
               nknots = atoi( snkn.c_str() );
               iknot=0;
               E     = new double[nknots];
               xsec  = new double[nknots];
 
               xmlFree(xname);
               xmlFree(xnkn);
            }
 
            if( (!xmlStrcmp(name, (const xmlChar *) "E"))    && type==kNodeTypeStartElement) { val_type = kKnotX; }
            if( (!xmlStrcmp(name, (const xmlChar *) "xsec")) && type==kNodeTypeStartElement) { val_type = kKnotY; }
 
            if( (!xmlStrcmp(name, (const xmlChar *) "#text")) && depth==5) {
                if      (val_type==kKnotX) E   [iknot] = atof((const char *)value);
                else if (val_type==kKnotY) xsec[iknot] = atof((const char *)value);
            }
            if( (!xmlStrcmp(name, (const xmlChar *) "knot")) && type==kNodeTypeEndElement) {
               iknot++;
            }
            if( (!xmlStrcmp(name, (const xmlChar *) "spline")) && type==kNodeTypeEndElement) {
#ifdef __GENIE_LOW_LEVEL_MESG_ENABLED__
               LOG("XSecSplLst", pINFO) << "Done with current spline";
               for(int i=0; i<nknots; i++) {
                  LOG("XSecSplLst", pINFO) << "xsec[E = " << E[i] << "] = " << xsec[i];
               }
#endif
               // done looping over knots - build the spline
               Spline * spline = new Spline(nknots, E, xsec);
               delete [] E;
               delete [] xsec;
 
               // insert the spline to the map
               map<string,  map<string, Spline *> >::iterator //\/
               mm_iter = fSplineMap.find( temp_tune );
               if(mm_iter == fSplineMap.end()) {
                 map<string, Spline *> spl_map_curr_tune;
                 fSplineMap.insert( map<string, map<string, Spline *> >::value_type(
                    temp_tune, spl_map_curr_tune) );
                 mm_iter = fSplineMap.find( temp_tune );
               }
               map<string, Spline *> & spl_map_curr_tune = mm_iter->second;
               spl_map_curr_tune.insert(
                  map<string, Spline *>::value_type(spline_name, spline) );
               fLoadedSplineSet[temp_tune].insert(spline_name);
            }
            xmlFree(name);
            xmlFree(value);
            ret = xmlTextReaderRead(reader);
        }
        xmlFreeTextReader(reader);
        if (ret != 0) {
          LOG("XSecSplLst", pERROR)
            << "\nXML file could not be parsed! [filename: " << filename << "]";
          return kXmlNotParsed;
        }
  } else {
    LOG("XSecSplLst", pERROR)
          << "\nXML file could not be found! [filename: " << filename << "]";
  }
 
  return kXmlOK;
}

References fLoadedSplineSet, fSplineMap, genie::kXmlInvalidRoot, genie::kXmlNotParsed, genie::kXmlOK, LOG, pDEBUG, pERROR, pINFO, pNOTICE, SetLogE(), SLOG, and genie::utils::str::TrimSpaces().

Referenced by LoadSplines(), main(), and genie::utils::app_init::XSecTable().

NKnots()

int genie::XSecSplineList::NKnots ( void ) const

inline

Definition at line 89 of file XSecSplineList.h.

{ return fNKnots;   }

References fNKnots.

Referenced by CreateSpline().

NSplines()

int genie::XSecSplineList::NSplines

(

void

)

const

Definition at line 299 of file XSecSplineList.cxx.

{
  map<string,  map<string, Spline *> >::const_iterator //
  mm_iter = fSplineMap.find(fCurrentTune);
  if(mm_iter == fSplineMap.end()) {
    SLOG("XSecSplLst", pWARN)
       << "No splines for tune " << fCurrentTune << " were found!";
    return 0;
  }
  const map<string, Spline *> & spl_map_curr_tune = mm_iter->second;
  return (int) spl_map_curr_tune.size();
}

References fCurrentTune, fSplineMap, pWARN, and SLOG.

Referenced by IsEmpty().

Print()

void genie::XSecSplineList::Print

(

ostream &

stream

)

const

Definition at line 583 of file XSecSplineList.cxx.

{
  stream << "\n ******************* XSecSplineList *************************";
  stream << "\n [-] Options:";
  stream << "\n  |";
  stream << "\n  |-----o  UseLogE..................." << fUseLogE;
  stream << "\n  |-----o  Spline Emin..............." << fEmin;
  stream << "\n  |-----o  Spline Emax..............." << fEmax;
  stream << "\n  |-----o  Spline NKnots............." << fNKnots;
  stream << "\n  |";
 
  map<string, map<string, Spline *> >::const_iterator mm_iter;
  for(mm_iter = fSplineMap.begin(); mm_iter != fSplineMap.end(); ++mm_iter) {
 
    string curr_tune = mm_iter->first;
    stream << "\n [-] Available x-section splines for tune: " << curr_tune ;
    stream << "\n  |";
 
    const map<string, Spline *> & spl_map_curr_tune = mm_iter->second;
    map<string, Spline *>::const_iterator m_iter = spl_map_curr_tune.begin();
    for( ; m_iter != spl_map_curr_tune.end(); ++m_iter) {
      string key = m_iter->first;
      stream << "\n  |-----o  " << key;
    }
    stream << "\n";
  }
}

References fEmax, fEmin, fNKnots, fSplineMap, and fUseLogE.

Referenced by operator<<.

SaveAsXml()

void genie::XSecSplineList::SaveAsXml	(	const string &	filename,
		bool	save_init = true ) const

Save XSecSplineList to XML file

Definition at line 339 of file XSecSplineList.cxx.

{
//! Save XSecSplineList to XML file
 
  SLOG("XSecSplLst", pNOTICE)
       << "Saving XSecSplineList as XML in file: " << filename;
 
  ofstream outxml(filename.c_str());
  if(!outxml.is_open()) {
    SLOG("XSecSplLst", pERROR) << "Couldn't create file = " << filename;
    return;
  }
  outxml << "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>";
  outxml << endl << endl;
  outxml << "<!-- generated by genie::XSecSplineList::SaveSplineList() -->";
  outxml << endl << endl;
 
  int uselog = (fUseLogE ? 1 : 0);
  outxml << "<genie_xsec_spline_list "
                << "version=\"3.00\" uselog=\"" << uselog << "\">";
  outxml << endl << endl;
 
  // loop over tunes
  map<string,  map<string, Spline *> >::const_iterator //\/
  mm_iter = fSplineMap.begin();
  for( ; mm_iter != fSplineMap.end(); ++mm_iter) {
 
    string tune_name = mm_iter->first;
    outxml << "  <genie_tune name=\"" << tune_name << "\">";
    outxml << endl << endl;
 
    // loop over splines for given tune
    const map<string, Spline *> & spl_map_curr_tune = mm_iter->second;
    map<string, Spline *>::const_iterator //\/
    m_iter = spl_map_curr_tune.begin();
    for( ; m_iter != spl_map_curr_tune.end(); ++m_iter) {
      string key = m_iter->first;
 
      // If current spline is from the initial loaded set,
      // look-up input option to decide whether to write out in
      // new output file or not
      bool from_init_set = false;
      map<string, set<string> >::const_iterator //\/
      it = fLoadedSplineSet.find(tune_name);
      if(it != fLoadedSplineSet.end()) {
         const set<string> & init_set_curr_tune = it->second;
         from_init_set = (init_set_curr_tune.count(key) == 1);
      }
      if(from_init_set && !save_init) continue;
 
      // Add current spline to output file
      Spline * spline = m_iter->second;
      spline->SaveAsXml(outxml,"E","xsec", key);
    }//spline loop
 
    outxml << "  </genie_tune>" << endl;
  }//tune loop
 
  outxml << "</genie_xsec_spline_list>" << endl;
 
  outxml.close();
}

References fLoadedSplineSet, fSplineMap, fUseLogE, pERROR, pNOTICE, genie::Spline::SaveAsXml(), and SLOG.

Referenced by main().

SetCurrentTune()

void genie::XSecSplineList::SetCurrentTune ( const string & tune )

inline

Definition at line 62 of file XSecSplineList.h.

{ fCurrentTune = tune; }

References fCurrentTune.

Referenced by genie::RunOpt::BuildTune().

SetLogE()

void genie::XSecSplineList::SetLogE

(

bool

on

)

set opt to build splines as f(E) or as f(logE)

Definition at line 318 of file XSecSplineList.cxx.

{
  fUseLogE = on;
}

References fUseLogE.

Referenced by genie::GEVGDriver::CreateSplines(), and LoadFromXml().

SetMaxE()

void genie::XSecSplineList::SetMaxE

(

double

Ev

)

set default maximum energy for xsec splines

Definition at line 334 of file XSecSplineList.cxx.

{
  if(Ev>0) fEmax = Ev;
}

References fEmax.

SetMinE()

void genie::XSecSplineList::SetMinE

(

double

Ev

)

set default minimum energy for xsec splines

Definition at line 329 of file XSecSplineList.cxx.

{
  if(Ev>0) fEmin = Ev;
}

References fEmin.

SetNKnots()

void genie::XSecSplineList::SetNKnots

(

int

nk

)

set default number of knots for building the spline

Definition at line 323 of file XSecSplineList.cxx.

{
  fNKnots = nk;
  if(fNKnots<10) fNKnots = 10; // minimum acceptable number of knots
}

References fNKnots.

SplineExists() [1/2]

bool genie::XSecSplineList::SplineExists	(	const XSecAlgorithmI *	alg,
		const Interaction *	i ) const

Definition at line 92 of file XSecSplineList.cxx.

{
  string key = this->BuildSplineKey(alg,interaction);
  return this->SplineExists(key);
}

References BuildSplineKey(), and SplineExists().

Referenced by genie::GEVGDriver::CreateSplines(), genie::AlamSimoAtharVacasSKXSec::Integrate(), genie::DISXSec::Integrate(), genie::DMDISXSec::Integrate(), genie::HEDISXSec::Integrate(), genie::HELeptonXSec::Integrate(), genie::ReinSehgalRESXSec::Integrate(), genie::ReinSehgalRESXSecFast::Integrate(), genie::SPPXSec::Integrate(), genie::PhysInteractionSelector::SelectInteraction(), SplineExists(), genie::GEVGDriver::UseSplines(), and genie::GEVGDriver::XSecSum().

SplineExists() [2/2]

bool genie::XSecSplineList::SplineExists

(

string

spline_key

)

const

Definition at line 99 of file XSecSplineList.cxx.

{
 
  if ( fCurrentTune.size() == 0 ) {
    SLOG("XSecSplLst", pERROR) << "Spline requested while CurrentTune not set" ;
    return false ;
  }
 
  SLOG("XSecSplLst", pDEBUG)
    << "Checking for spline: " << key << " in tune: " << fCurrentTune;
 
  map<string,  map<string, Spline *> >::const_iterator //
  mm_iter = fSplineMap.find(fCurrentTune);
  if(mm_iter == fSplineMap.end()) {
    SLOG("XSecSplLst", pWARN)
       << "No splines for tune " << fCurrentTune << " were found!";
    return false;
  }
  const map<string, Spline *> & spl_map_curr_tune = mm_iter->second;
  bool exists = (spl_map_curr_tune.count(key) == 1);
  SLOG("XSecSplLst", pDEBUG)
    << "Spline found?...." << utils::print::BoolAsYNString(exists);
  return exists;
}

References genie::utils::print::BoolAsYNString(), fCurrentTune, fSplineMap, pDEBUG, pERROR, pWARN, and SLOG.

UseLogE()

bool genie::XSecSplineList::UseLogE ( void ) const

inline

Definition at line 88 of file XSecSplineList.h.

{ return fUseLogE;  }

References fUseLogE.

Referenced by CreateSpline().

Friends And Related Symbol Documentation

Cleaner

friend struct Cleaner

friend

Definition at line 120 of file XSecSplineList.h.

operator<<

ostream & operator<< ( ostream & stream, const XSecSplineList & xsl )

friend

Definition at line 44 of file XSecSplineList.cxx.

{
  list.Print(stream);
  return stream;
}

References Print(), and XSecSplineList().

Member Data Documentation

fCurrentTune

string genie::XSecSplineList::fCurrentTune

private

The ‘active’ tune, out the many that can co-exist.

Definition at line 106 of file XSecSplineList.h.

Referenced by CreateSpline(), CurrentTune(), GetSpline(), GetSplineKeys(), NSplines(), SetCurrentTune(), SplineExists(), and XSecSplineList().

fEmax

double genie::XSecSplineList::fEmax

private

Definition at line 104 of file XSecSplineList.h.

Referenced by Emax(), Print(), SetMaxE(), and XSecSplineList().

fEmin

double genie::XSecSplineList::fEmin

private

Definition at line 103 of file XSecSplineList.h.

Referenced by Emin(), Print(), SetMinE(), and XSecSplineList().

fInstance

XSecSplineList * genie::XSecSplineList::fInstance = 0

staticprivate

Definition at line 99 of file XSecSplineList.h.

Referenced by Instance(), XSecSplineList(), genie::XSecSplineList::Cleaner::~Cleaner(), and ~XSecSplineList().

fLoadedSplineSet

map<string, set<string> > genie::XSecSplineList::fLoadedSplineSet

private

tune -> { set of initialy loaded splines }

Definition at line 109 of file XSecSplineList.h.

Referenced by LoadFromXml(), and SaveAsXml().

fNKnots

int genie::XSecSplineList::fNKnots

private

Definition at line 102 of file XSecSplineList.h.

Referenced by NKnots(), Print(), SetNKnots(), and XSecSplineList().

fSplineMap

map<string, map<string, Spline *> > genie::XSecSplineList::fSplineMap

private

tune -> { xsec_alg/xsec_config/interaction -> Spline }

Definition at line 108 of file XSecSplineList.h.

Referenced by CreateSpline(), GetSpline(), GetSplineKeys(), HasSplineFromTune(), LoadFromXml(), NSplines(), Print(), SaveAsXml(), SplineExists(), and ~XSecSplineList().

fUseLogE

bool genie::XSecSplineList::fUseLogE

private

Definition at line 101 of file XSecSplineList.h.

Referenced by Print(), SaveAsXml(), SetLogE(), UseLogE(), and XSecSplineList().

---

The documentation for this class was generated from the following files:

• XSecSplineList.h
• XSecSplineList.cxx