Load.cpp

//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidDataHandling/Load.h"
#include "MantidAPI/FileProperty.h"
#include "MantidKernel/ArrayProperty.h"
#include "MantidDataObjects/Workspace2D.h"
#include "MantidAPI/LoadAlgorithmFactory.h"
#include<algorithm>


namespace Mantid
{
  namespace DataHandling
  {
    // Register the algorithm into the algorithm factory
    DECLARE_ALGORITHM(Load);

    using namespace Kernel;
    using namespace API;

    /// Default constructor
    Load::Load() : IDataFileChecker(), m_header_buffer(NULL) 
    {
    }

    /**
     * Quick file always returns false here
     * @param filePath File path
     * @param nread Number of bytes read
     * @param header_buffer A buffer containing the nread bytes
     */
    bool Load::quickFileCheck(const std::string& filePath,size_t nread,const file_header& header)
    {
      (void)filePath; (void)nread; (void)header;
      return false;
    }

    /**
     * File check by looking at the structure of the data file
     * @param filePath The full file path
     * @returns -1
     */
    int Load::fileCheck(const std::string& filePath)
    {
      (void)filePath;
      return -1;
    }

    /// Initialisation method.
    void Load::init()
    {
      
      std::vector<std::string> exts;
      exts.push_back(".raw");
      exts.push_back(".s*");
      exts.push_back(".add");

      exts.push_back(".nxs");
      exts.push_back(".nx5");
      exts.push_back(".xml");
      exts.push_back(".n*");

      exts.push_back(".dat");
      exts.push_back(".txt");
      exts.push_back(".csv");

      exts.push_back(".spe");
   
      declareProperty(new FileProperty("Filename", "", FileProperty::Load, exts),
		      "The name of the file to read, including its full or relative\n"
		      "path. (N.B. case sensitive if running on Linux).");
      declareProperty(new WorkspaceProperty<Workspace>("OutputWorkspace", "",Direction::Output, true), 
		      "The name of the workspace that will be created, filled with the\n"
		      "read-in data and stored in the Analysis Data Service.");
      declareProperty("FindLoader", false, "If true the algorithm will only be run as\n"
 		      "far as is necessary to discover the concrete Load algorithm to use");
      declareProperty("LoaderName", std::string(""), "A string containing the name of the concrete loader used", 
 		      Direction::Output);
    }

    namespace 
    {
      //@cond
      /** 
       * Checks this property exists in the list of algorithm properties.
       */
      struct hasProperty
      { 
	/** constructor which takes 1 arguement.
	 *@param name :: name of the property
	 */
	hasProperty(const std::string name):m_name(name){}
	
	/**This method comapres teh property name
	 *@param prop :: shared pointer to property
	 *@return true if the property exists in the list of properties.
	 */
	bool operator()(Mantid::Kernel::Property* prop)
	{
	  std::string name=prop->name();
	  return (!name.compare(m_name));
	}
	/// name of teh property
	std::string m_name;
      };

      //@endcond
    }

    /** 
     *   Executes the algorithm.
     */
    void Load::exec()
    {
      std::string fileName = getPropertyValue("Filename");
      std::string::size_type i = fileName.find_last_of('.');
      std::string ext = fileName.substr(i+1);
      std::transform(ext.begin(),ext.end(),ext.begin(),tolower);
      //get the shared pointer to the specialised load algorithm to execute  
      API::IAlgorithm_sptr loader = getFileLoader(fileName);
      if( !loader )
      {
        throw std::runtime_error("Cannot find a loader for \"" + fileName + "\"");
      }
      else
      {
	setPropertyValue("LoaderName", loader->name());
      }
      
      bool findOnly = getProperty("FindLoader");
      if( findOnly ) return;

      g_log.information()<<"The sub load algorithm  created to execute is "
			 << loader->name() << "  and it version is  " 
			 << loader->version() <<std::endl;
      double startProgress(0.0), endProgress(1.0);
      initialiseLoadSubAlgorithm(loader,startProgress,endProgress,true,-1);
  
      //get the list of properties for this algorithm
      std::vector<Kernel::Property*> props=getProperties();
      ///get the list properties for the sub load algorithm
      std::vector<Kernel::Property*>loader_props=loader->getProperties();
      
      //loop through the properties of this algorithm 
      std::vector<Kernel::Property*>::iterator itr;
      for (itr=props.begin();itr!=props.end();++itr)
      {        
	std::vector<Mantid::Kernel::Property*>::iterator prop;
	//if  the load sub algorithm has the same property then set it.
	prop=std::find_if(loader_props.begin(),loader_props.end(),hasProperty((*itr)->name()));
	if(prop!=loader_props.end())
	{ 
          
	  loader->setPropertyValue((*prop)->name(),getPropertyValue((*prop)->name()));
	}
        
      }
      // Execute the concrete loader
      loader->execute();
      // Set the workspace. Deals with possible multiple periods
      setOutputWorkspace(loader);          
    }

    /** Get a shared pointer to the load algorithm with highest preference for loading
     *@param filePath :: path of the file
     *@return filePath - path of the file
     */
    API::IAlgorithm_sptr Load::getFileLoader(const std::string& filePath)
    {
      /* Open the file and read in the first bufferSize bytes - these will
       * be used to determine the type of the file
       */
      FILE* fp = fopen(filePath.c_str(), "rb");
      if (fp == NULL)
      {
	throw Kernel::Exception::FileError("Unable to open the file:", filePath);
      }
      //unsigned char* header_buffer = header_buffer_union.c;
      //unsigned char * header_buffer = IDataFileChecker::g_hdr_buf.get();
      file_header header;
      int nread = fread(&header,sizeof(unsigned char), g_hdr_bytes, fp);
      // Ensure the character string is null terminated.
      header.full_hdr[g_hdr_bytes] = '\0';
      if (nread == -1)
      {
	fclose(fp);
      }

      if (fclose(fp) != 0)
      {
	throw std::runtime_error("Error while closing file \"" + filePath + "\"");
      } 
      
      // Iterate through all loaders and attempt to find the best qualified for the job.
      // Each algorithm has a quick and long file check. The long version returns an integer
      // giving its certainty about be able to load the file. The highest wins.
      std::vector<std::string> loaderNames = API::LoadAlgorithmFactory::Instance().getKeys();
      int highestPref(0);
      API::IAlgorithm_sptr winningLoader;
      std::vector<std::string>::const_iterator cend = loaderNames.end();
      for( std::vector<std::string>::const_iterator citr = loaderNames.begin(); citr != cend;
	   ++citr )
      {
	IDataFileChecker_sptr loader = API::LoadAlgorithmFactory::Instance().create(*citr);
	if( loader->quickFileCheck(filePath, nread, header) )
	{
	  int pref = loader->fileCheck(filePath);
	  // Can't just pick the first as there might be one later in the list with a higher
	  // preference
	  if( pref > highestPref )
	  {
	    highestPref = pref;
	    winningLoader = loader;
	  }
	}
      }

      if( !winningLoader )
      {
	throw std::runtime_error("Cannot find a loader for \"" + filePath + "\"");
      }
      return winningLoader;
    }

    /** This method set the algorithm as a child algorithm.
     *  @param alg :: The shared pointer to a  algorithm
     *  @param startProgress :: The percentage progress value of the overall 
     *  algorithm where this child algorithm starts
     *  @param endProgress :: The percentage progress value of the overall 
     *  algorithm where this child algorithm ends
     *  @param enableLogging :: Set to false to disable logging from the child algorithm
     *  @param version ::  The version of the child algorithm to create. 
     *  By default gives the latest version.
     */
    void Load::initialiseLoadSubAlgorithm(API::IAlgorithm_sptr alg, 
					  const double startProgress, const double endProgress, 
					  const bool enableLogging, const int& version)
    {
      (void) version; // Avoid compiler warning.
      //Set as a child so that we are in control of output storage
      alg->initialize();
      alg->setChild(true);
      alg->setLogging(enableLogging);

      // If output workspaces are nameless, give them a temporary name to satisfy validator
      const std::vector< Property*> &props = alg->getProperties();
      for (unsigned int i = 0; i < props.size(); ++i)
      {
	if (props[i]->direction() == 1 && dynamic_cast<IWorkspaceProperty*>(props[i]) )
	{
	  if ( props[i]->value().empty() ) props[i]->setValue("LoadChildWorkspace");
	}
      }

      if (startProgress >= 0. && endProgress > startProgress && endProgress <= 1.)
      {
	alg->addObserver(m_progressObserver);
	alg->setChildStartProgress(startProgress);
	alg->setChildEndProgress(endProgress);
      }

    }
        
    /**
     * Set the output workspace(s) if the load's return workspace
     *  has type API::Workspace
     *@param load :: shared pointer to load algorithm
     */
    void Load::setOutputWorkspace(API::IAlgorithm_sptr& load)
    {
      try
      {
	Workspace_sptr ws = load->getProperty("OutputWorkspace"); 
	WorkspaceGroup_sptr wsg = boost::dynamic_pointer_cast<WorkspaceGroup>(ws);
	if (wsg)
	{
	  setProperty("OutputWorkspace",ws);
	  std::vector<std::string> names = wsg->getNames();
	  for(size_t i = 0; i < names.size(); ++i)
	  {
	    std::ostringstream propName;
	    propName << "OutputWorkspace_" << (i+1);
	    DataObjects::Workspace2D_sptr memberwsws1 = load->getProperty(propName.str());

	    std::string memberwsName = load->getPropertyValue(propName.str());
	    declareProperty(new WorkspaceProperty<>(propName.str(),memberwsName,Direction::Output));
	    setProperty(propName.str(),boost::dynamic_pointer_cast<MatrixWorkspace>(memberwsws1));
	  }
	}
	else
	{ 
	  setProperty("OutputWorkspace",ws);
	}
      }
      catch(std::runtime_error&)
      {
	MatrixWorkspace_sptr mws=load->getProperty("OutputWorkspace");
	setProperty("OutputWorkspace",boost::dynamic_pointer_cast<Workspace>(mws));
      }
         
     
    }

  
  } // namespace DataHandling
} // namespace Mantid