ReadNeXusFile.hh

/*
$Id: ReadNeXusFile.hh 2247 2011-04-27 05:20:41Z jisuzuki $
 */

#ifndef READNEXUSFILE
#define READNEXUSFILE

#include <map>
#include "Header.hh"
#include "HeaderBase.hh"
#include "SplitString.hh"
#include "ElementContainer.hh"
#include "NeutronVector.hh"
#include "UInt4Container.hh"
#include "napi.h"
#include "ElementContainerArray.hh"
#include "ElementContainerMatrix.hh"
#include "UInt4ContainerArray.hh"
#include "UInt4ContainerMatrix.hh"
#include "TwoDimElementContainer.hh"


class ReadNeXusFile
{
private:
  SplitString *ss;
  UInt4 w_handleFlag;
protected:
  NXhandle handle;
  void OpenNeXusFile( const string &FileName );
  void CloseNeXusFile();
  Int4 CurrentNumber;
  
public:
  ReadNeXusFile( const string &FileName );
  ReadNeXusFile( NXhandle w_handle );
 ~ReadNeXusFile();

  NXhandle PutHandle(){ return handle; }

  vector<string> GetGroupInfo();
  vector<string> GetNextEntry();
  vector<Int4>   GetInfo();
  Int4 PutCurrentNumber(){ return CurrentNumber; };
  void OpenGroup( const string &GroupName, const string &GroupClass );
  void CloseGroup(){ NXclosegroup( handle ); }
  void OpenData( const string &DataSetName );
  void CloseData(){ NXclosedata( handle ); }
  void ReadData(const string &Name, UInt4 &i);
  void ReadData(const string &Name, Int4 &i);
  void ReadData(const string &Name, Double &d);
  void ReadData(const string &Name, string &s);
  void ReadData(const string &Name, vector<UInt4> &vi);
  void ReadData(const string &Name, vector<Int4> &vi);
  void ReadData(const string &Name, vector<Double> &vd);
  void ReadData(const string &Name, vector<string> &vs);

  UInt4 ReadDataUInt4( const string &Name ) {
        UInt4 i;
        ReadData(Name, i);
        return i;
  }
  Int4 ReadDataInt4( const string &Name ) {
        Int4 i;
        ReadData(Name, i);
        return i;
  }
  Double ReadDataDouble( const string &Name ) {
        Double d;
        ReadData(Name, d);
        return d;
  }
  string ReadDataString( const string &Name ) {
        string s;
        ReadData(Name, s);
        return s;
  }
  vector<Double> ReadDoubleVector( const string &Name ) {
        vector<Double> vd;
        ReadData(Name, vd);
        return vd;
  }
  vector<Int4>   ReadInt4Vector( const string &Name ) {
        vector<Int4> vi;
        ReadData(Name, vi);
        return vi;
  }
  vector<UInt4>  ReadUInt4Vector( const string &Name ) {
        vector<UInt4> vi;
        ReadData(Name, vi);
        return vi;
  }
  vector<string> ReadStringVector( const string &Name ) {
        vector<string> vs;
        ReadData(Name, vs);
        return vs;
  }
  HeaderBase ReadHeaderBase( const string &Name ) {
        HeaderBase header;
        ReadData(Name, header);
        return header;
  }
  ElementContainer ReadElementContainer( const string &Name ) {
        ElementContainer EC;
        ReadData(Name, EC);
        return EC;
  }
  ElementContainerArray ReadElementContainerArray( const string &Name ) {
        ElementContainerArray ECA;
        ReadData(Name, ECA);
        return ECA;
  }
  ElementContainerMatrix ReadElementContainerMatrix( const string &Name ) {
        ElementContainerMatrix ECM;
        ReadData(Name, ECM);
        return ECM;
  }
  UInt4Container ReadUInt4Container( const string &Name ) {
        UInt4Container UC;
        ReadData(Name, UC);
        return UC;
  }
  UInt4ContainerArray ReadUInt4ContainerArray( const string &Name ) {
        UInt4ContainerArray UCA;
        ReadData(Name, UCA);
        return UCA;
  }
  UInt4ContainerMatrix  ReadUInt4ContainerMatrix( const string &Name ) {
        UInt4ContainerMatrix UCM;
        ReadData(Name, UCM);
        return UCM;
  }


  template <class T>
  void ReadData( const string &Name, T &t ) {
        OpenGroup( Name, "NXdata" );

        try {
          UInt4 v = GetAttribute2<UInt4>("version");

          if (v==2) {
                ReadData2(t);
          } else {
                std::cerr << "ReadNeXusFile::ReadData(): unsupported version: "
                                  << v << std::endl;
          }
        }
        catch (NXstatus s) {
          // no "version" means version1 (old code)
          ReadData1(t);
        }

        CloseGroup();
  }


  template <class T>
  void ReadData( const string &Name, std::map<string, T> &t );


  template <class T>
  void ReadData( const string &Name, std::vector<T *> &t );


private:
  template <class T>
  void ReadData2(T &t ) {
        t.NXread(*this);
  }

  template <class T>
  void ReadData1( Map<T> &H ) {
        std::cout << "CAUTION: ReadNeXusFile::ReadData1(const string &Name, Map<T> &H) shouldn't be called" << std::endl;
  }

  void ReadData1( StlMapDouble &H ) {
        std::cout << "CAUTION: ReadNeXusFile::ReadData1(const string &Name, StlMapDouble &H) shouldn't be called" << std::endl;
  }

  void ReadData1( HeaderBase &H );
  void ReadData1( ElementContainer &EC );
  void ReadData1( ElementContainerArray &ECA );
  void ReadData1( ElementContainerMatrix &ECM );
  void ReadData1( UInt4Container &UC );
  void ReadData1( UInt4ContainerArray &UCA );
  void ReadData1( UInt4ContainerMatrix &UCM );


public:
  TwoDimElementContainer ReadTwoDimElementContainer( const string &Name );

private:  
  ElementContainer ReadElementContainer1( const string &Name ) {
        ElementContainer EC;
        OpenGroup( Name, "NXdata" );
        ReadData1(EC);
        CloseGroup();
        return EC;
  }
  HeaderBase ReadHeaderBase1( const string &Name ) {
        HeaderBase HB;
        OpenGroup( Name, "NXdata" );
        ReadData1(HB);
        CloseGroup();
        return HB;
  }
  ElementContainerArray ReadElementContainerArray1( const string &Name ) {
        ElementContainerArray ECA;
        OpenGroup( Name, "NXdata" );
        ReadData1(ECA);
        CloseGroup();
        return ECA;
  }
  ElementContainerMatrix ReadElementContainerMatrix1( const string &Name ) {
        ElementContainerMatrix ECM;
        OpenGroup( Name, "NXdata" );
        ReadData1(ECM);
        CloseGroup();
        return ECM;
  }
  UInt4ContainerMatrix  ReadUInt4ContainerMatrix1( const string &Name ) {
        UInt4ContainerMatrix UCM;
        OpenGroup( Name, "NXdata" );
        ReadData1(UCM);
        CloseGroup();
        return UCM;
  }
  UInt4ContainerArray ReadUInt4ContainerArray1( const string &Name ) {
        UInt4ContainerArray UCA;
        OpenGroup( Name, "NXdata" );
        ReadData1(UCA);
        CloseGroup();
        return UCA;
  }
  UInt4Container ReadUInt4Container1( const string &Name ) {
        UInt4Container UC;
        OpenGroup( Name, "NXdata" );
        ReadData1(UC);
        CloseGroup();
        return UC;
  }
  template <class T>
  T GetAttribute2(const string &Name);


  template <class T>
  UInt4 GetAttribute3( NXhandle handle, string Name, T *value,
                                           Int4 DataLength, Int4 DataType ) {
        return NXgetattr( handle, const_cast<char *>(Name.c_str()), static_cast<void *>(value),
                                        &DataLength, &DataType );
  }

public:
  NXstatus GetNextEntry2( char *Name, char *nxclass, int *type) {
        return NXgetnextentry(handle, Name, nxclass, type);
  }
};

template <class T>
void ReadNeXusFile::
ReadData( const string &Name, std::map<string, T> &t )
{
  OpenGroup( Name, "NXdata" );

  NXname _name, _class;
  int _id, _status;

  std::vector<std::string> keys;
  while ((_status=GetNextEntry2(_name, _class, &_id))==1) {
//      std::cerr << "NEXTENTRY: " << _name << "," << _class << ", "
//                        << _id << "," << _status << std::endl;
        std::string _s(_name);
        ReadData(_s, t[_s]);
        keys.push_back(_s);
  }

  for (typename std::map<std::string, T>::iterator p=t.begin(),
                 end=t.end();p!=end;++p) {
        // if p->first (key) does not exist in keys vector
        // then p (keys, val) should be removed
        if ((std::find(keys.begin(), keys.end(), p->first))==keys.end())
          t.erase(p);
        // is this code really safe?
  }
                 
  CloseGroup();
}

template <class T>
void ReadNeXusFile::
ReadData( const string &Name, std::vector<T *> &t )
{
  OpenGroup( Name, "NXdata" );
  Int4 newsize = ReadDataInt4("size");
  Int4 cursize = t.size();

  for (signed int i=newsize;i<cursize;++i)
        delete t[i];
  t.resize(newsize);
  for (signed int i=cursize;i<newsize;++i)
        t[i] = new T;

  UInt4 i=0;
  static char index[128];
  for (typename std::vector<T *>::iterator p=t.begin(),
                 end=t.end();p!=end;++p, ++i) {
        sprintf(index, "%s%d", Name.c_str(), i);
        ReadData(index, **p);
  }

  CloseGroup();
}

template <class T>
T ReadNeXusFile::
GetAttribute2(const string &Name){
  NXstatus status = 0;
  
  while( status != -1 ){
        NXname AttrName;
        Int4 Length;
        Int4 Type;
    status = NXgetnextattr( handle, AttrName, &Length, &Type );
    //cout << "AttrName = " << AttrName << endl;
    string StAttrName = string( AttrName );
    //cout << "StAttrName = " << StAttrName << " " << Name << endl;
    if( StAttrName == Name ){
          T val;

          GetAttribute3<T>(handle, Name, &val, Length, Type);
          // following doesn't work
          //NXgetattr( handle, const_cast<char *>(Name.c_str()), (void*)(val), &Length, &Type );

      return val;
    }
  }

  // if attribute is not exist
  throw (-1); // NXstatus
}
#endif


/* Test code on Python environment.
r = Neutron.ReadNeXusFile( "nx.nx" )

vs = r.GetNextEntry()
r.OpenGroup( vs[0], vs[1] )

vs = r.GetNextEntry()
r.OpenGroup( vs[0], vs[1] )

vs = r.GetNextEntry()
E = r.ReadElementContainer( vs[0] )

r.CloseGroup()
r.CloseGroup()
del r


 */