Sample.cpp

//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidAPI/Sample.h"
#include "MantidKernel/Strings.h"
#include "MantidAPI/SampleEnvironment.h"
#include "MantidGeometry/IComponent.h"
#include "MantidGeometry/Crystal/OrientedLattice.h"
#include "MantidGeometry/Objects/ShapeFactory.h"
#include "MantidNexusCPP/NeXusException.hpp"

using namespace Mantid::Kernel;
using Mantid::Geometry::ShapeFactory;

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);
      file->putAttr("shape_xml", m_shape.getShapeXML());

      m_material.saveNexus(file, "material");
      // Write out the other (indexes 1+) samples
      file->writeData("num_other_samples", int(m_samples.size()) );
      for (size_t i=0; i<m_samples.size(); i++)
        m_samples[i]->saveNexus(file, "sample" + Strings::toString(i+1));
      //TODO: SampleEnvironment
      // OrientedLattice
      if (hasOrientedLattice())
      {
        file->writeData("num_oriented_lattice", 1 );
        m_lattice->saveNexus(file, "oriented_lattice");
      }
      else
        file->writeData("num_oriented_lattice", 0 );

      // Legacy info from RAW file (I think)
      file->writeData("geom_id", m_geom_id);
      file->writeData("geom_thickness", m_thick);
      file->writeData("geom_height", m_height);
      file->writeData("geom_width", m_width);

      file->closeGroup();
    }

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

      // Version 0 = saveNexusProcessed before Sep 8, 2011
      int version = 0;
      try {  file->getAttr("version", version);  }
      catch (::NeXus::Exception &)   { version=0; }

      if (version == 0)
      {
        // Sample NAME field may/may not be present
        try {  file->readData("name", m_name); }
        catch (::NeXus::Exception &) { m_name = ""; }
      }

      if (version > 0)
      {
        // Name is an attribute
        file->getAttr("name", m_name);

        // Shape (from XML)
        std::string shape_xml;
        file->getAttr("shape_xml", shape_xml);
        shape_xml = Strings::strip(shape_xml);
        if (!shape_xml.empty())
        {
          ShapeFactory shapeMaker;
          m_shape = *shapeMaker.createShape(shape_xml, false /*Don't wrap with <type> tag*/);
        }

        m_material.loadNexus(file, "material");
        // Load other samples
        int num_other_samples;
        file->readData("num_other_samples", num_other_samples);
        for (int i=0; i < num_other_samples; i++)
        {
          boost::shared_ptr<Sample> extra(new Sample);
          extra->loadNexus(file, "sample" + Strings::toString(i+1));
          this->addSample(extra);
        }

        // OrientedLattice
        int num_oriented_lattice;
        file->readData("num_oriented_lattice", num_oriented_lattice );
        if (num_oriented_lattice > 0)
        {
          m_lattice = new OrientedLattice;
          m_lattice->loadNexus(file, "oriented_lattice");
        }
      }

      try
      {
        // Legacy info from RAW file (I think)
        file->readData("geom_id", m_geom_id);
        file->readData("geom_thickness", m_thick);
        file->readData("geom_height", m_height);
        file->readData("geom_width", m_width);
      }
      catch (...)
      { /* Very old files don't have them. Ignore. */ }

      file->closeGroup();

      return version;
    }


  }
}