Sample.cpp

//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidAPI/Sample.h"
#include "MantidKernel/Strings.h"
#include "MantidAPI/SampleEnvironment.h"
#include "MantidGeometry/IComponent.h"

namespace Mantid
{

  namespace API
  {

    using Geometry::Object;
    using Geometry::Material;
    using Kernel::V3D;
    
    /**
     * Default constructor
     */
    Sample::Sample() : 
      m_name(), m_shape(), m_material(), m_environment(),
      m_lattice(NULL),m_samples(),
      m_geom_id(0), m_thick(0.0), m_height(0.0), m_width(0.0)
    {
    }

    /** 
     * Copy constructor 
     *  @param copy :: const reference to the sample object
     */
    Sample::Sample(const Sample& copy) :
      m_name(copy.m_name), m_shape(copy.m_shape), m_material(copy.m_material), 
      m_environment(copy.m_environment),
      m_lattice(NULL),m_samples(copy.m_samples),
      m_geom_id(copy.m_geom_id), m_thick(copy.m_thick),
      m_height(copy.m_height), m_width(copy.m_width)
    {
      if (copy.m_lattice)
        m_lattice = new OrientedLattice(copy.getOrientedLattice());
    }

    /** Assignment operator 
     * @param rhs :: const reference to the sample object
     * @return A reference to this object, which will have the same 
     * state as the argument
     */
    Sample& Sample::operator=(const Sample& rhs)
    {
      if (this == &rhs) return *this;
      m_name = rhs.m_name;
      m_shape = rhs.m_shape;
      m_material = rhs.m_material;
      m_environment = rhs.m_environment;
      m_geom_id = rhs.m_geom_id;
      m_samples = std::vector<boost::shared_ptr<Sample> >(rhs.m_samples);
      m_thick = rhs.m_thick;
      m_height = rhs.m_height;
      m_width = rhs.m_width;
      if (rhs.m_lattice)
        m_lattice = new OrientedLattice(rhs.getOrientedLattice());
      else
        m_lattice = NULL;

      return *this;
    }
  
    /** 
     * Returns the name of the sample
     * @returns The name of this  sample
     */
    const std::string & Sample::getName() const
    {
      return m_name;
    }

    /** 
     * Update the name of the sample
     * @param name :: The name of the sample
     */
    void Sample::setName(const std::string & name)
    {
      m_name = name;
    }

    /**
     * Get a pointer to the sample shape object. It is assumed that this is defined within
     * its own coordinate system with its centre at [0,0,0]
     * @return A reference to the object describing the shape
     */
    const Object& Sample::getShape() const
    {
      return m_shape;
    }

    /** Set the object that describes the sample shape. It is assumed that this is defined such
     * that its centre is at [0,0,0]
     * @param object :: The object describing the shape
     * @throw An std::invalid_argument error if the object does 
     * not have a valid shape
     */
    void Sample::setShape(const Object & object)
    {
      if( object.hasValidShape() )
      {
        m_shape = object;
      }
      else
      {
        throw std::invalid_argument("Sample::setShape - Object has an invalid shape.");
      }
    }

    /** Return the material.
     * @return A reference to the material the sample is composed of
     */
    const Material & Sample::getMaterial() const
    {
      return m_material;
    }
    
    /**
     * Set the type of material that this sample is composed from
     * @param material :: A reference to the material object. It is copied into the sample.
     */
    void Sample::setMaterial(const Geometry::Material& material)
    {
      m_material = material;
    }

    /**
     * Return a reference to the sample environment that this sample is attached to
     * @return A const reference to a SampleEnvironment object
     * @throw std::runtime_error If the environment has not been defined
     */
    const SampleEnvironment & Sample::getEnvironment() const
    {
      if( !m_environment )
      {
        throw std::runtime_error("Sample::getEnvironment - No sample enviroment has been defined.");
      }
      return *m_environment;
    }

    /**
     * Attach an environment onto this sample
     * @param env :: A pointer to a created sample environment. This takes 
     * ownership of the object.
     */
    void Sample::setEnvironment(SampleEnvironment * env)
    {
      m_environment = boost::shared_ptr<SampleEnvironment>(env);
    }

    /** Return a const reference to the OrientedLattice of this sample
     * @return A const reference to a OrientedLattice object
     * @throw std::runtime_error If the OrientedLattice has not been defined
     */
    const OrientedLattice & Sample::getOrientedLattice() const
    {
      if( !m_lattice )
      {
        throw std::runtime_error("Sample::getOrientedLattice - No OrientedLattice has been defined.");
      }
      return *m_lattice;
    }

    /** Return a reference to the OrientedLattice of this sample
     * @return A reference to a OrientedLattice object
     * @throw std::runtime_error If the OrientedLattice has not been defined
     */
    OrientedLattice & Sample::getOrientedLattice()
    {
      if( !m_lattice )
      {
        throw std::runtime_error("Sample::getOrientedLattice - No OrientedLattice has been defined.");
      }
      return *m_lattice;
    }

    /** Attach an OrientedLattice onto this sample
     *
     * @param env :: A pointer to a OrientedLattice.
     */
    void Sample::setOrientedLattice(OrientedLattice * latt)
    {
      m_lattice = latt;
    }

    /** @return true if the sample has an OrientedLattice  */
    bool Sample::hasOrientedLattice() const
    { return (m_lattice != NULL); }

    /**
     * Set the geometry flag that is specfied in the raw file within the SPB_STRUCT
     * 1 = cylinder, 2 = flat plate, 3 = disc, 4 = single crystal
     * @param geom_id :: The flag for the geometry
     */
    void Sample::setGeometryFlag(int geom_id)
    {
      m_geom_id = geom_id;
    }

    /**
     * Get the geometry flag that is specified in the raw file within the SPB_STRUCT
     * 1 = cylinder, 2 = flat plate, 3 = disc, 4 = single crystal
     * @returns The flag for the sample geometry
     */
    int Sample::getGeometryFlag() const
    {
      return m_geom_id;
    }

    /**
     * Set the thickness value
     * @param thick :: The parameter e_thick in the SPB_STRUCT
     */
    void Sample::setThickness(double thick)
    {
      m_thick = thick;
    }

    /**
     * Get the thickness value
     * @returns The parameter thickness parameter
     */
    double Sample::getThickness() const
    {
      return m_thick;
    }

    /**
     * Set the height value
     * @param height :: The parameter e_height in the SPB_STRUCT
     */
    void Sample::setHeight(double height)
    {
      m_height = height;
    }

    /**
     * Get the height value
     * @returns The parameter height parameter
     */
    double Sample::getHeight() const
    {
      return m_height;
    }

    /**
     * Set the width value
     * @param width :: The parameter e_width in the SPB_STRUCT
     */
    void Sample::setWidth(double width)
    {
      m_width = width;
    }

    /**
     * Get the height value
     * @returns The parameter height parameter
     */
    double Sample::getWidth() const
    {
      return m_width;
    }

    /**
     * Gets the desired sample, 0 is the current sample
     * @param index The index of the desired sample
     * @returns The desired sample
     */
    Sample& Sample::operator[] (const int index)
    {
      if (index == 0)
      {
        return *this;
      }
      else if ((static_cast<std::size_t>(index) > m_samples.size()) || ( index < 0))
      {
        throw std::out_of_range("The index value provided was out of range");
      }
      else
      {
        return *m_samples[index-1];
      }
    }

    /**
     * Gets the number of samples in this collection
     * @returns The count of samples
     */
    std::size_t Sample::size() const
    {
      return m_samples.size()+1;
    }
    

    /**
     * Adds a sample to the sample collection
     * @param childSample The child sample to be added
     */
    void Sample::addSample(boost::shared_ptr<Sample> childSample)
    {
      m_samples.push_back(childSample);
    }


    /** Save the object to an open NeXus file.
     * @param file :: open NeXus file
     * @param group :: name of the group to create
     */
    void Sample::saveNexus(::NeXus::File * file, const std::string & group) const
    {
//      file->makeGroup(group, "NXsample", 1);
//      file->putAttr("name", m_name);
//      file->putAttr("version", 1);
//      m_material.saveNexus(file, "material");
//      // Write out the other (indexes 1+) samples
//      file->writeData("num_other_samples", m_samples.size() );
//      for (size_t i=0; i<m_samples.size(); i++)
//        m_samples[i]->saveNexus(file, "sample" + Mantid::Kernel::Strings::toString(i+1));
//      //TODO: Sample, environment
//      file->closeGroup();
    }

    /** Load the object from an open NeXus file.
     * @param file :: open NeXus file
     * @param group :: name of the group to open
     */
    void Sample::loadNexus(::NeXus::File * file, const std::string & group)
    {
      file->openGroup(group, "NXsample");
      file->closeGroup();
    }


  }
}