marley::StructureDatabase Class Reference

Container for nuclear structure information organized by nuclide. More...

#include <StructureDatabase.hh>

Public Member Functions
	StructureDatabase ()
	Creates an empty database.
void	add_decay_scheme (int pdg, std::unique_ptr< marley::DecayScheme > &ds)
	Add a DecayScheme object to the database that contains discrete level data for a specific nuclide.
void	clear ()
	Removes all previously stored data from the database.
const std::unordered_map< int, std::unique_ptr< marley::DecayScheme > > &	decay_schemes () const
	Retrieves a const reference to the table of DecayScheme objects.
void	emplace_decay_scheme (int pdg, const std::string &filename, DecayScheme::FileFormat format=DecayScheme::FileFormat::talys)
	Construct and add a DecayScheme object to the database that contains discrete level data for a specific nuclide.
std::set< int >	find_all_nuclides (const std::string &filename, DecayScheme::FileFormat format=DecayScheme::FileFormat::talys)
	Create a set of Particle Data Group codes for every nuclide in a discrete level data file.
marley::DecayScheme *	get_decay_scheme (const int particle_id)
	Retrieves discrete level data from the database.
marley::DecayScheme *	get_decay_scheme (const int Z, const int A)
	Retrieves discrete level data from the database.
int	get_fragment_l_max () const
	Returns the maximum orbital angular momentum to consider when simulating fragment emission to the continuum.
int	get_gamma_l_max () const
	Returns the maximum multipolarity to consider when simulating gamma-ray emission to the continuum.
marley::GammaStrengthFunctionModel &	get_gamma_strength_function_model (const int nuc_pdg)
	Retrieves a gamma-ray strength function model object from the database, creating it if one did not already exist.
marley::GammaStrengthFunctionModel &	get_gamma_strength_function_model (const int Z, const int A)
	Retrieves a gamma-ray strength function model object from the database, creating it if one did not already exist.
marley::LevelDensityModel &	get_level_density_model (const int nucleus_pid)
	Retrieves a level density model object from the database, creating it if one did not already exist.
marley::LevelDensityModel &	get_level_density_model (const int Z, const int A)
	Retrieves a level density model object from the database, creating it if one did not already exist.
marley::OpticalModel &	get_optical_model (const int Z, const int A)
	Retrieves an optical model object from the database, creating it if one did not already exist.
marley::OpticalModel &	get_optical_model (int nucleus_pid)
	Retrieves an optical model object from the database, creating it if one did not already exist.
void	load_optical_model_params (const marley::JSON *om_config=nullptr)
	Helper function that initializes the map of JSON settings for the optical model parameters.
void	remove_decay_scheme (int pdg)
	Deletes the discrete level data in the database associated with a given nuclide.
void	set_fragment_l_max (int ell)
	Sets the maximum orbital angular momentum to consider when simulating fragment emission to the continuum.
void	set_gamma_l_max (int ell)
	Sets the maximum multipolarity to consider when simulating gamma-ray emission to the continuum.

Static Public Member Functions
static const std::map< int, marley::Fragment > &	fragments ()
	Retrieves a const reference to the table of Fragment objects.
static const marley::Fragment *	get_fragment (const int fragment_pdg)
	Retrieves nuclear fragment data from the database.
static const marley::Fragment *	get_fragment (const int Z, const int A)
	Retrieves nuclear fragment data from the database.
static void	get_gs_spin_parity (const int Z, const int A, int &twoJ, marley::Parity &Pi)
	Looks up the ground-state spin-parity for a particular nuclide.
static void	get_gs_spin_parity (int nuc_pdg, int &twoJ, marley::Parity &Pi)
	Looks up the ground-state spin-parity for a particular nuclide.

Detailed Description

Container for nuclear structure information organized by nuclide.

Currently, the StructureDatabase object can hold nuclear discrete level data (DecayScheme objects), optical models (OpticalModel objects), \(\gamma\)-ray strength function models (GammaStrengthFunctionModel objects), and level density models (LevelDensityModel objects)

Definition at line 40 of file StructureDatabase.hh.

Constructor & Destructor Documentation

StructureDatabase()

marley::StructureDatabase::StructureDatabase

(

)

Creates an empty database.

Definition at line 57 of file StructureDatabase.cc.

{}

Member Function Documentation

add_decay_scheme()

void marley::StructureDatabase::add_decay_scheme	(	int	pdg,
		std::unique_ptr< marley::DecayScheme > &	ds )

Add a DecayScheme object to the database that contains discrete level data for a specific nuclide.

Parameters

pdg	PDG code for the desired nuclide
ds	A unique_ptr to DecayScheme object to move into the database.

Definition at line 59 of file StructureDatabase.cc.

{
  auto* temp_ptr = ds.release();
  decay_scheme_table_.emplace(pdg, std::unique_ptr<marley::DecayScheme>(temp_ptr));
}

Referenced by get_decay_scheme().

clear()

void marley::StructureDatabase::clear

(

)

Removes all previously stored data from the database.

Definition at line 335 of file StructureDatabase.cc.

                                    {
  decay_scheme_table_.clear();
}

decay_schemes()

const std::unordered_map< int, std::unique_ptr< marley::DecayScheme > > & marley::StructureDatabase::decay_schemes ( ) const

inline

Retrieves a const reference to the table of DecayScheme objects.

Definition at line 135 of file StructureDatabase.hh.

      {
        return decay_scheme_table_;
      }

emplace_decay_scheme()

void marley::StructureDatabase::emplace_decay_scheme	(	int	pdg,
		const std::string &	filename,
		DecayScheme::FileFormat	format = DecayScheme::FileFormat::talys )

Construct and add a DecayScheme object to the database that contains discrete level data for a specific nuclide.

Parameters

pdg	PDG code for the desired nuclide
filename	Name of the file that contains the discrete level data
format	DecayScheme::FileFormat specifier that indicates which nuclear data format is used in the file

Definition at line 66 of file StructureDatabase.cc.

{
  int Z_ds = (pdg % 10000000)/10000;
  int A_ds = (pdg % 10000)/10;
 
  // Remove the previous entry (if one exists) for the given PDG code
  decay_scheme_table_.erase(pdg);
 
  // Add the new entry
  decay_scheme_table_.emplace(pdg, std::make_unique<marley::DecayScheme>(
    Z_ds, A_ds, filename, format));
}

find_all_nuclides()

std::set< int > marley::StructureDatabase::find_all_nuclides	(	const std::string &	filename,
		DecayScheme::FileFormat	format = DecayScheme::FileFormat::talys )

Create a set of Particle Data Group codes for every nuclide in a discrete level data file.

Parameters

filename	Name of the file that contains the discrete level data
format	DecayScheme::FileFormat specifier that indicates which nuclear data format is used in the file

Definition at line 80 of file StructureDatabase.cc.

{
  if (format != DecayScheme::FileFormat::talys)
    throw marley::Error(std::string("StructureDatabase::")
      + "find_all_nuclides() is not implemented for"
      + " formats other than TALYS.");
 
  // First line in a TALYS level dataset has fortran
  // format (2i4, 2i5, 56x, i4, a2)
  // General regex for this line:
  static const std::regex nuclide_line("[0-9 ]{18} {56}[0-9 ]{4}.{2}");
 
  // Open the TALYs level data file for parsing
  std::ifstream file_in(filename);
 
  // If the file doesn't exist or some other error
  // occurred, complain and give up.
  if (!file_in.good()) throw marley::Error(std::string("Could not")
    + " read from the TALYS data file " + filename);
 
  std::string line; // String to store the current line
                    // of the TALYS file during parsing
 
  std::istringstream iss; // String stream used to parse the line
 
  double Z; // atomic number
  double A; // mass number
 
  // Particle Data Group codes for each nuclide in the file
  std::set<int> PDGs;
 
  // Loop through the data file, recording all nuclide PDGs found
  while (std::getline(file_in, line)) {
    if (std::regex_match(line, nuclide_line)) {
      // Load the new line into our istringstream object for parsing. Reset
      // the stream so that we start parsing from the beginning of the string.
      iss.str(line);
      iss.clear();
 
      // The first two entries on a TALYS nuclide line are Z and A.
      iss >> Z >> A;
 
      PDGs.insert(marley_utils::get_nucleus_pid(Z, A));
    }
  }
 
  file_in.close();
 
  return PDGs;
}

fragments()

static const std::map< int, marley::Fragment > & marley::StructureDatabase::fragments ( )

inlinestatic

Retrieves a const reference to the table of Fragment objects.

Definition at line 141 of file StructureDatabase.hh.

                                                                   {
        if ( !initialized_gs_spin_parity_table_ ) initialize_jpi_table();
        return fragment_table_;
      }

Referenced by marley::MassTable::unbound_threshold().

get_decay_scheme() [1/2]

marley::DecayScheme * marley::StructureDatabase::get_decay_scheme

(

const int

particle_id

)

Retrieves discrete level data from the database.

Parameters

particle_id

PDG code for the desired nuclide

Returns

pointer to the requested nuclide's DecayScheme object, or nullptr if one could not be found

Definition at line 132 of file StructureDatabase.cc.

{
  // If we already have the DecayScheme object stored in the lookup table,
  // then just retrieve it
  auto iter = decay_scheme_table_.find( particle_id );
  if ( iter != decay_scheme_table_.end() ) return iter->second.get();
  // If not, see if a data file for it is listed in the index
  else {
 
    marley::TargetAtom ta_requested( particle_id );
    MARLEY_LOG( DEBUG, "init.structure.decay" )
      << "Looking up structure data for " << ta_requested;
 
    if ( !loaded_structure_index_ ) this->load_structure_index();
    auto ds_file_iter = decay_scheme_filenames_.find( particle_id );
 
    // If not, then just give up and return a null pointer
    if ( ds_file_iter == decay_scheme_filenames_.end() ) {
      MARLEY_LOG( NOTICE, "init.structure.decay" ) << "No tabulated decay"
        " scheme available for " << ta_requested << ". The Hauser-Feshbach"
        " statistical model will be used for de-excitation.";
      // Cache the null result to avoid repeating the lookup
      decay_scheme_table_[ particle_id ] = nullptr;
      return nullptr;
    }
 
    // If a file is available, load all of the decay schemes present in it
    // and add them to the lookup table. If we find the one we're looking
    // for, return a pointer to it. Otherwise, print a warning, give up,
    // and return a null pointer.
    std::string ds_file_name = ds_file_iter->second;
    auto& fm = marley::FileManager::Instance();
    std::string full_ds_file_name = fm.find_file( ds_file_name );
    std::ifstream ds_data_file( full_ds_file_name );
    bool found_it = false;
    auto temp_ds = std::make_unique< marley::DecayScheme >();
    int loaded_nuclide_count = 0;
    while ( ds_data_file >> *temp_ds ) {
      int ds_pdg = temp_ds->pdg();
      if ( particle_id == ds_pdg ) found_it = true;
      this->add_decay_scheme( ds_pdg, temp_ds );
      marley::TargetAtom ta( ds_pdg );
      MARLEY_LOG( DEBUG, "init.structure.decay" ) << "Added decay scheme for "
        << ta << " from " << full_ds_file_name;
      ++loaded_nuclide_count;
      temp_ds = std::make_unique< marley::DecayScheme >();
    }
    if ( !found_it ) {
      MARLEY_LOG( WARN, "init.structure.decay" )
        << "Failed to load nuclear structure data for " << ta_requested
        << " from the file " << ds_file_name;
      // Make a nullptr entry in the lookup table to avoid duplicate attempts
      // to load the missing data
      decay_scheme_table_[ particle_id ] = nullptr;
    }
    if ( loaded_nuclide_count > 0 ) {
      MARLEY_LOG( INFO, "init.structure.decay" ) << "Loaded structure data for "
        << loaded_nuclide_count << " nuclides from the file "
        << full_ds_file_name;
    }
 
    // Return the pointer to the newly-loaded DecayScheme (or nullptr
    // if it could not be loaded) via recursion
    return this->get_decay_scheme( particle_id );
  }
}

References add_decay_scheme(), get_decay_scheme(), and marley::FileManager::Instance().

Referenced by marley::CommandHandler::cmd_decay(), get_decay_scheme(), get_decay_scheme(), and marley::NucleusDecayer::process_event().

get_decay_scheme() [2/2]

marley::DecayScheme * marley::StructureDatabase::get_decay_scheme	(	const int	Z,
		const int	A )

Retrieves discrete level data from the database.

Parameters

Z	atomic number
A	mass number

Returns

pointer to the requested nuclide's DecayScheme object, or nullptr if one could not be found

Definition at line 200 of file StructureDatabase.cc.

{
  int particle_id = marley_utils::get_nucleus_pid(Z, A);
  return get_decay_scheme( particle_id );
}

References get_decay_scheme().

get_fragment() [1/2]

const marley::Fragment * marley::StructureDatabase::get_fragment ( const int fragment_pdg )

static

Retrieves nuclear fragment data from the database.

Parameters

fragment_pdg

PDG code for the desired fragment

Returns

Pointer to the requested Fragment object, or nullptr if it could not be found

Definition at line 339 of file StructureDatabase.cc.

{
  // Before retrieving the fragment, make sure we've loaded the
  // necessary data tables
  if ( !initialized_gs_spin_parity_table_ ) initialize_jpi_table();
  auto iter = fragment_table_.find( fragment_pdg );
  if ( iter == fragment_table_.end() ) return nullptr;
  else return &iter->second;
}

Referenced by get_fragment().

get_fragment() [2/2]

const marley::Fragment * marley::StructureDatabase::get_fragment ( const int Z, const int A )

static

Retrieves nuclear fragment data from the database.

Parameters

Z	Fragment proton number
A	Fragment mass number

Returns

Pointer to the requested Fragment object, or nullptr if it could not be found

Definition at line 350 of file StructureDatabase.cc.

{
  int fragment_pdg = marley_utils::get_nucleus_pid( Z, A );
  return get_fragment( fragment_pdg );
}

References get_fragment().

get_fragment_l_max()

int marley::StructureDatabase::get_fragment_l_max ( ) const

inline

Returns the maximum orbital angular momentum to consider when simulating fragment emission to the continuum.

Definition at line 161 of file StructureDatabase.hh.

{ return fragment_l_max_; }

get_gamma_l_max()

int marley::StructureDatabase::get_gamma_l_max ( ) const

inline

Returns the maximum multipolarity to consider when simulating gamma-ray emission to the continuum.

Definition at line 165 of file StructureDatabase.hh.

{ return gamma_l_max_; }

get_gamma_strength_function_model() [1/2]

marley::GammaStrengthFunctionModel & marley::StructureDatabase::get_gamma_strength_function_model

(

const int

nuc_pdg

)

Retrieves a gamma-ray strength function model object from the database, creating it if one did not already exist.

Parameters

nuc_pdg

PDG code for the nuclide of interest

Definition at line 301 of file StructureDatabase.cc.

{
  int Z = marley_utils::get_particle_Z( nuc_pdg );
  int A = marley_utils::get_particle_A( nuc_pdg );
  return this->get_gamma_strength_function_model( Z, A );
}

References get_gamma_strength_function_model().

get_gamma_strength_function_model() [2/2]

marley::GammaStrengthFunctionModel & marley::StructureDatabase::get_gamma_strength_function_model	(	const int	Z,
		const int	A )

Retrieves a gamma-ray strength function model object from the database, creating it if one did not already exist.

Parameters

Z	atomic number
A	mass number

Definition at line 310 of file StructureDatabase.cc.

{
  int pid = marley_utils::get_nucleus_pid(Z, A);
 
  auto iter = gamma_strength_function_table_.find(pid);
 
  if (iter == gamma_strength_function_table_.end()) {
    // The requested gamma-ray strength function model wasn't found, so create
    // it and add it to the table, returning a reference to the stored strength
    // function model afterwards.
    return *(gamma_strength_function_table_.emplace(pid,
      std::make_unique<marley::StandardLorentzianModel>(Z, A)).first
      ->second.get());
  }
  else return *(iter->second.get());
}

Referenced by get_gamma_strength_function_model().

get_gs_spin_parity() [1/2]

void marley::StructureDatabase::get_gs_spin_parity ( const int Z, const int A, int & twoJ, marley::Parity & Pi )

static

Looks up the ground-state spin-parity for a particular nuclide.

Parameters

[in]	Z	Proton number for the nuclide of interest
[in]	A	Mass number for the nuclide of interest
[out]	twoJ	Two times the ground-state nuclear spin
[out]	Pi	Ground-state nuclear parity

Definition at line 357 of file StructureDatabase.cc.

{
  int nuc_pdg = marley_utils::get_nucleus_pid( Z, A );
  return get_gs_spin_parity( nuc_pdg, twoJ, Pi );
}

References get_gs_spin_parity().

get_gs_spin_parity() [2/2]

void marley::StructureDatabase::get_gs_spin_parity ( int nuc_pdg, int & twoJ, marley::Parity & Pi )

static

Looks up the ground-state spin-parity for a particular nuclide.

Parameters

[in]	nuc_pdg	PDG code for the nuclide of interest
[out]	twoJ	Two times the ground-state nuclear spin
[out]	Pi	Ground-state nuclear parity

Definition at line 364 of file StructureDatabase.cc.

{
  if ( !initialized_gs_spin_parity_table_ ) initialize_jpi_table();
  auto iter = jpi_table_.find( nuc_pdg );
  if ( iter == jpi_table_.end() ) throw marley::Error( "Unrecognized"
    " nuclear PDG code " + std::to_string(nuc_pdg) + " passed to"
    " marley::StructureDatabase::get_gs_spin_parity()" );
  auto pair = iter->second;
  twoJ = pair.first;
  Pi = pair.second;
}

Referenced by get_gs_spin_parity().

get_level_density_model() [1/2]

marley::LevelDensityModel & marley::StructureDatabase::get_level_density_model

(

const int

nucleus_pid

)

Retrieves a level density model object from the database, creating it if one did not already exist.

Parameters

nucleus_pid

PDG particle ID for the desired nucleus

Definition at line 275 of file StructureDatabase.cc.

{
  auto iter = level_density_table_.find(nucleus_pid);
 
  if (iter == level_density_table_.end()) {
    // The requested level density model wasn't found, so create it and add it
    // to the table, returning a reference to the stored level density model
    // afterwards.
    int Z = marley_utils::get_particle_Z( nucleus_pid );
    int A = marley_utils::get_particle_A( nucleus_pid );
    return *(level_density_table_.emplace(nucleus_pid,
      std::make_unique<marley::BackshiftedFermiGasModel>(Z, A)).first
      ->second.get());
  }
  else return *(iter->second.get());
}

Referenced by get_level_density_model().

get_level_density_model() [2/2]

marley::LevelDensityModel & marley::StructureDatabase::get_level_density_model	(	const int	Z,
		const int	A )

Retrieves a level density model object from the database, creating it if one did not already exist.

Parameters

Z	atomic number
A	mass number

Definition at line 293 of file StructureDatabase.cc.

{
  int pid = marley_utils::get_nucleus_pid(Z, A);
  return this->get_level_density_model( pid );
}

References get_level_density_model().

get_optical_model() [1/2]

marley::OpticalModel & marley::StructureDatabase::get_optical_model	(	const int	Z,
		const int	A )

Retrieves an optical model object from the database, creating it if one did not already exist.

Parameters

Z	atomic number
A	mass number

Definition at line 242 of file StructureDatabase.cc.

{
  int nucleus_pid = marley_utils::get_nucleus_pid( Z, A );
  auto iter = optical_model_table_.find( nucleus_pid );
 
  if ( iter == optical_model_table_.end() ) {
 
    if ( om_config_map_.empty() ) this->load_optical_model_params();
 
    // Check for a nucleus-specific optical model configuration (stored under
    // the nuclear PDG code as a string key) first. If it's not present, pull
    // up the default set of parameters. If the default set isn't present,
    // complain.
    auto iter = om_config_map_.find( std::to_string(nucleus_pid) );
    if ( iter == om_config_map_.end() ) {
      iter = om_config_map_.find( DEFAULT_OM_KEY );
      if ( iter == om_config_map_.end() ) throw marley::Error( "Missing '"
        + DEFAULT_OM_KEY + "' key in optical model JSON configuration" );
    }
 
    const auto& om_config = iter->second;
 
    // The requested optical model wasn't found, so create it and add it
    // to the table, returning a reference to the stored optical model
    // afterwards.
    return *( optical_model_table_.emplace( nucleus_pid,
      std::make_unique< marley::KoningDelarocheOpticalModel >(
      Z, A, om_config) ).first->second.get() );
  }
  else return *( iter->second.get() );
}

References load_optical_model_params().

get_optical_model() [2/2]

marley::OpticalModel & marley::StructureDatabase::get_optical_model

(

int

nucleus_pid

)

Retrieves an optical model object from the database, creating it if one did not already exist.

Parameters

particle_id

PDG particle ID for the desired nuclide

Todo

add check for invalid nucleus particle ID value

Definition at line 207 of file StructureDatabase.cc.

{
  auto iter = optical_model_table_.find( nucleus_pid );
 
  if ( iter == optical_model_table_.end() ) {
    // The requested optical model wasn't found, so create it and add it
    // to the table, returning a reference to the stored optical model
    // afterwards.
    int Z = marley_utils::get_particle_Z( nucleus_pid );
    int A = marley_utils::get_particle_A( nucleus_pid );
 
    if ( om_config_map_.empty() ) this->load_optical_model_params();
 
    // Check for a nucleus-specific optical model configuration (stored under
    // the nuclear PDG code as a string key) first. If it's not present, pull
    // up the default set of parameters. If the default set isn't present,
    // complain.
    auto iter = om_config_map_.find( std::to_string(nucleus_pid) );
    if ( iter == om_config_map_.end() ) {
      iter = om_config_map_.find( DEFAULT_OM_KEY );
      if ( iter == om_config_map_.end() ) throw marley::Error( "Missing '"
        + DEFAULT_OM_KEY + "' key in optical model JSON configuration" );
    }
 
    const auto& om_config = iter->second;
 
    return *( optical_model_table_.emplace( nucleus_pid,
      std::make_unique< marley::KoningDelarocheOpticalModel >(
      Z, A, om_config) ).first->second.get() );
  }
  else return *( iter->second.get() );
}

References load_optical_model_params().

load_optical_model_params()

void marley::StructureDatabase::load_optical_model_params

(

const marley::JSON *

om_config = nullptr

)

Helper function that initializes the map of JSON settings for the optical model parameters.

Definition at line 469 of file StructureDatabase.cc.

{
  // Boolean flag for checking that JSON parsing was successful
  bool ok;
 
  // If we've been passed a JSON configuration, then use it
  if ( om_config ) {
    om_config_map_ = assign_from_json< std::map<std::string, marley::JSON> >(
      *om_config, ok );
  }
  // Otherwise, fetch the default one from the standard data file
  else {
    const auto& fm = marley::FileManager::Instance();
    const std::string om_file_name( "optical_model_kduq_federal_cv.js" );
    std::string om_full_file_name = fm.find_file( om_file_name );
 
    if ( om_full_file_name.empty() ) {
      throw marley::Error( "Could not find the MARLEY nuclear optical model"
        " configuration file " + om_file_name + ". Please ensure that"
        " the folder containing it is on the MARLEY search path."
        " If needed, the folder can be appended to the MARLEY_SEARCH_PATH"
        " environment variable." );
    }
 
    MARLEY_LOG( INFO, "init.structure" ) << "Loading nuclear optical model parameters from "
      << om_full_file_name;
 
    auto temp_config = marley::JSON::load_file( om_full_file_name );
    om_config_map_ = assign_from_json< std::map<std::string, marley::JSON> >(
      temp_config, ok );
  }
 
  if ( !ok ) throw marley::Error( "Failed to parse optical model"
    " JSON configuration" );
}

References marley::FileManager::Instance().

Referenced by get_optical_model(), and get_optical_model().

remove_decay_scheme()

void marley::StructureDatabase::remove_decay_scheme

(

int

pdg

)

Deletes the discrete level data in the database associated with a given nuclide.

If a decay scheme does not exist in the database for the requested nuclide, then this function will return without making any changes.

Parameters

pdg	PDG code for the nuclide to remove

Definition at line 328 of file StructureDatabase.cc.

{
  // Remove the decay scheme with this PDG code if it exists in the database.
  // If it doesn't, do nothing.
  decay_scheme_table_.erase( pdg );
}

set_fragment_l_max()

void marley::StructureDatabase::set_fragment_l_max ( int ell )

inline

Sets the maximum orbital angular momentum to consider when simulating fragment emission to the continuum.

Definition at line 169 of file StructureDatabase.hh.

{ fragment_l_max_ = ell; }

set_gamma_l_max()

void marley::StructureDatabase::set_gamma_l_max ( int ell )

inline

Sets the maximum multipolarity to consider when simulating gamma-ray emission to the continuum.

Definition at line 173 of file StructureDatabase.hh.

{ gamma_l_max_ = ell; }

---

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

• /home/sjg/Desktop/marley/include/marley/StructureDatabase.hh
• /home/sjg/Desktop/marley/src/StructureDatabase.cc