ElementContainer.hh

/*
$Id: ElementContainer.hh 2295 2011-08-10 02:57:13Z jisuzuki $
*/


#ifndef ELEMENTCONTAINER
#define ELEMENTCONTAINER

#include <algorithm>
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/string.hpp>
#include <napi.h>

#include "Header.hh"
#include "HeaderBase.hh"
#include "CppToPython.hh"
#include "StlMapDouble.hh"
#include "NeutronWriteBinaryData.hh"
#include "NeutronReadBinaryData.hh"
#include "SimpleIOVectorToTextFile.hh"


class ElementContainer
{
private:

  // If the vector named "Error-key" in the argument contains
  // a negative value element, this method returns "true".
  bool IsMaskData( vector<Double> &v, const vector<Double> *vp );



  //vector< vector< Double >* > v;
  //vector< string > s;
  StlMapDouble M;
  HeaderBase *header;
  HeaderBase *UnitHeader;

  string Xkey, Ykey, Ekey;

  void _Add( const string &Key, vector< Double > &value, string Unit="None" )
  {  M.Add( Key, value ); UnitHeader -> Add( Key, Unit ); }


  void Formatter2(
        const std::vector<Double> *rx, const std::vector<Double> *&ry,
        const std::vector<Double> *&re);

  friend class boost::serialization::access;
  template <class Archive>
  void serialize(Archive &ar, const unsigned int ver);

  friend class WriteNeXusFile;
  template <class Write>
  void NXwrite(Write &W) const ;

  friend class ReadNeXusFile;
  template <class Read>
  void NXread(Read &R) ;

protected:

public:
  ElementContainer();
  ElementContainer( const HeaderBase &Header );
  ElementContainer( const ElementContainer &ob );
 ~ElementContainer();
  ElementContainer &operator=( const ElementContainer &ob );
  ElementContainer &operator+=(const ElementContainer &r );
  ElementContainer &MaskedPlus(const ElementContainer &r );
  ElementContainer &MaskedSub( const ElementContainer &r );
  ElementContainer &MaskedMul( const ElementContainer &r );
  ElementContainer &MaskedDiv( const ElementContainer &r );
  

  ElementContainer &operator+=( const std::pair<Double, Double> &r );
  ElementContainer &operator+=( const Double r ) {
        return *this += std::make_pair(r, 0.0);
  }
  ElementContainer operator+(const ElementContainer &r ) const {
        ElementContainer result(*this);
        return result += r;
  }
  ElementContainer operator+(const std::pair<Double, Double> &r ) const {
        ElementContainer result(*this);
        return result += r;
  }
  ElementContainer operator+(const Double r ) const {
        ElementContainer result(*this);
        return result += r;
  }
  ElementContainer &operator-=(const ElementContainer &r );
  ElementContainer &operator-=( const std::pair<Double, Double> &r );
  ElementContainer &operator-=( const Double r ) {
        return *this -= std::make_pair(r, 0.0);
  }
  ElementContainer operator-( ElementContainer &r ) const {
        ElementContainer result(*this);
        return result -= r;
  }
  ElementContainer operator-(const std::pair<Double, Double> &r ) const {
        ElementContainer result(*this);
        return result -= r;
  }
  ElementContainer operator-(const Double r ) const {
        ElementContainer result(*this);
        return result -= r;
  }
  ElementContainer &operator*=(const ElementContainer &r );
  ElementContainer &operator*=( const std::pair<Double, Double> &r );
  ElementContainer &operator*=( const Double r ) {
        return *this *= std::make_pair(r, 0.0);
  }
  ElementContainer operator*( ElementContainer &r ) const {
        ElementContainer result(*this);
        return result *= r;
  }
  ElementContainer operator*(const std::pair<Double, Double> &r ) const {
        ElementContainer result(*this);
        return result *= r;
  }
  ElementContainer operator*(const Double r ) const {
        ElementContainer result(*this);
        return result *= r;
  }
  ElementContainer &operator/=(const ElementContainer &r );
  ElementContainer &operator/=( const std::pair<Double, Double> &r );
  ElementContainer &operator/=( const Double r ) {
        return *this /= std::make_pair(r, 0.0);
  }
  ElementContainer operator/( ElementContainer &r ) const {
        ElementContainer result(*this);
        return result /= r;
  }
  ElementContainer operator/(const std::pair<Double, Double> &r ) const {
        ElementContainer result(*this);
        return result /= r;
  }
  ElementContainer operator/(const Double r ) const {
        ElementContainer result(*this);
        return result /= r;
  }
  ElementContainer ReBin( ElementContainer &E, string &Key ){return ReBin( E.Put( Key ) );}
  ElementContainer ReBin( const vector<Double> &v );
  ElementContainer Binning( const vector<Double> &v );
  ElementContainer Binning( ElementContainer &E, string &Key )
  {return Binning( E.Put( Key ) );}

  ElementContainer Averaging( const vector<Double> &v );
  ElementContainer Averaging( ElementContainer &E, string &Key )
  {return Averaging( E.Put( Key ) );}
  
  
  void SetKeys( const string &X, const string &Y, const string &E );
  const string &PutXKey() const { return Xkey; }
  const string &PutYKey() const { return Ykey; }
  const string &PutEKey() const { return Ekey; }
  vector<Double> PutX();
  vector<Double> PutY();
  vector<Double> PutE();
  PyObject *PutXList(){ return PutList( PutXKey() ); }
  PyObject *PutYList(){ return PutList( PutYKey() ); }
  PyObject *PutEList(){ return PutList( PutEKey() ); }
  UInt4 PutTableSize() const { return M.Size(); }
  UInt4 PutSize() const { return PutTableSize(); }
  UInt4 PutSize( UInt4 IndexNumber ) const { return M(IndexNumber) -> size(); }
  UInt4 PutSize( const string &Key ) const { return M.Size(Key); }
  Int8 PutIndexNumber( const string &Key ){return M.PutIndexNumber( Key );}
  string PutName( UInt4 IndexNumber );
  //{ return (M.PutKeyList())[IndexNumber]; }
  vector<string> PutKeys();
  PyObject *PutKeysList();

  HeaderBase PutUnitHeader(){return *UnitHeader;}
  HeaderBase PutHeader(){return *header;}
  HeaderBase *PutHeaderPointer(){ return header; }
  void InputUnitHeader( const HeaderBase &uHeader );
  void InputHeader( const HeaderBase &Header );
  void ReSetUnit( string key, string unit ){ UnitHeader->OverWrite( key,unit); }

  void DumpKey();
  void Add( const string &Key, vector< Double > value, const string &Unit="None" );
  void Add( const string &Key, vector< Float  > value, const string &Unit="None" );
  void Add( const string &Key, vector< UInt4  > value, const string &Unit="None" );
  void Add( const string &Key, vector< UInt2  > value, const string &Unit="None" );
  void Add( const string &Key, PyObject *value, const string &Unit="None" );
  void Add( const string &Key, Double *&Array, UInt4 ArraySize, const string &Unit="None" );
  void Add( const string &Key, Float *&Array, UInt4 ArraySize, const string &Unit="None" );
  void Add( const string &Key, UInt4 *&Array, UInt4 ArraySize, const string &Unit="None" );
  void Add( const string &Key, UInt2 *&Array, UInt4 ArraySize, const string &Unit="None" );
  void AddBlankVector( const string &Key, UInt4 Size=0, const string &Unit="None" );
  vector<Double> Find( const string &Key ){ return Put(Key); }
  vector<Double> Find( UInt4 IndexNumber ){ return Put(IndexNumber); }
  Double Find( const string &Key, UInt4 Index ){return ( Put(Key) )[Index]; }
  vector<Double> Put( UInt4 IndexNumber ){return M.Put( IndexNumber );}
  vector<Double> Put( const string &Key ){return M.Put( Key );}
  Double Put( const string &Key, UInt4 Index ){ return Find(Key,Index); }
  string PutUnit( const string &Key ) const;
  void SetUnit( const string &Key, const string &NewUnit );

  PyObject *PutList( const string &Key ){return __gCppToPython.VectorDoubleToList( Put( Key ) );}
  vector<Double> ReduceColumn( const string &Key );
  PyObject *ReduceColumnList( const string &Key ){return __gCppToPython.
    VectorDoubleToList( ReduceColumn( Key ) );
  }

  UInt4 CheckKey( const string &Key ){return M.CheckKey( Key );}
  void Copy( const string &Old, const string &New );
  void Remove( const string &Key );
  void Replace( const string &Key, const vector<Double> &value );
  void Replace( const string &Key, PyObject *value );
  void AppendValue( const string &Key, Double value ){M( Key ) -> push_back( value );}
  void AppendValue( const string &Key, const vector<Double> &value );
  void SetValue( const string &Key, UInt4 Number, Double value );
  template <class T>
  void Transform(const std::string &Key, T F, const std::string &newunit="None");

  void Reverse(void) { M.Reverse(); }

  void Dump();
  PyObject* PyDump();

  void dump() {DumpValue();}

  void DumpValue();
  void DumpFromVectorContainer();
  void DumpFromVectorContainer( UInt4 size );

  void Dump( UInt4 size );
  void DumpValue( UInt4 size );

  string PutXYEKeys();
  string PutMergedKey();
  vector<UInt4> PutSizeVector();
  vector<Double> PutMergedDataVector();

  void BuildElementContainer( string XYEKeys, 
                              string MergedKey, 
                              vector<UInt4> SizeVector, 
                              vector<Double> MergedDataVector,
                              HeaderBase h, 
                              HeaderBase uh );
  vector<Double>* operator()( const string &Key ){return M( Key );}
  vector<Double>* operator()( UInt4 index ){return M( index );}
  void AddToHeader( const string &Key, Int4   value ){ header->Add( Key, value ); }
  void AddToHeader( const string &Key, Double value ){ header->Add( Key, value ); }
  void AddToHeader( const string &Key, string value ){ header->Add( Key, value ); }
  void AddToHeader( const string &Key, vector<Int4>   value ){ header->Add( Key, value ); }
  void AddToHeader( const string &Key, vector<Double> value ){ header->Add( Key, value ); }
  void AddToHeader( const string &Key, vector<string> value ){ header->Add( Key, value ); }
  Double Sum( const string &key, const UInt4 i0, const UInt4 i1 ) const;
  Double Sum( const string &key ) const;
  Double Sum( void ) const;
  std::pair<Double, Double> Sum( const string &key, const string &err_key, UInt4 i0, UInt4 i1 ) const;
  std::pair<Double, Double> Sum( const string &key, const string &err_key ) const;
  std::pair<Double, Double> Sum2( void ) const ;
  std::pair<Double, Double> Sum( Double ini, Double fin ) const;
  Double Ave( const string &key );
  Double Ave( const string &key, const string &err );
  Double Min( const string &key );
  Double Max( const string &key );
  std::pair<Double, Double> Integrate();
//  vector<Double> Integrate( UInt4 ini, UInt4 fin );
  std::pair<Double, Double> Integrate( Double ini, Double fin );
  void SaveToBinFile( string key, string FileName );
  void ReadBinFile( string FileName, string key );
  void SaveTextFile( string FileName );
  void SaveTextFile( string FileName, Int4 prec );
  void SaveTextFile( string FileName, Char deli );
  void SaveTextFile( string FileName, Int4 prec, Char deli );
  void LoadTextFile( string FileName );
  bool safesum; 
  // http://en.wikipedia.org/wiki/Kahan_summation_algorithm
  // warning, Ave(string, string) doesn't performs this safe summation yet

  
  // developing methods
  ElementContainer Mul( Double d );
  ElementContainer &MulMySelf( Double d );
  ElementContainer Mul( Double d, Double e );
  ElementContainer &MulMySelf( Double d, Double e );
  ElementContainer Mul( pair<Double,Double> &d ){ return Mul(d.first,d.second); }
  ElementContainer &MulMySelf( pair<Double,Double> &d ){ return MulMySelf(d.first,d.second); }
  
  ElementContainer Plus( Double d );
  ElementContainer &PlusMySelf( Double d );
  ElementContainer Plus( Double d, Double e );
  ElementContainer &PlusMySelf( Double d, Double e );
  ElementContainer Plus( pair<Double,Double> &d ){ return Plus(d.first,d.second); }
  ElementContainer &PlusMySelf( pair<Double,Double> &d ){ return PlusMySelf(d.first,d.second); }
};

template <class Archive>
void ElementContainer::
serialize(Archive &ar, const unsigned int ver) {
  ar & boost::serialization::make_nvp("XKey", Xkey);
  ar & boost::serialization::make_nvp("YKey", Ykey);
  ar & boost::serialization::make_nvp("EKey", Ekey);

  ar & boost::serialization::make_nvp("Header", *header);
  ar & boost::serialization::make_nvp("UnitHeader", *UnitHeader);

  ar & boost::serialization::make_nvp("ElementContainerData", M);
}

template <class T>
void ElementContainer::
Transform(const std::string &Key, T F, const std::string &newunit) {
  if( CheckKey( Key ) != 1 ){
        cout << "ElementContainer::Transform(string)" 
                 << endl;
        cout << Key << " is not found in this container." << endl;
        return;
  }
  vector< Double > &vec = *M( Key );

  std::transform(vec.begin(), vec.end(), vec.begin(), F);
  ReSetUnit(Key, newunit);
}

template <class Write>
void ElementContainer::
NXwrite(Write &W) const {
  W.WriteData("XKey", Xkey);
  W.WriteData("YKey", Ykey);
  W.WriteData("EKey", Ekey);

  if (!header->Empty())
  W.WriteData("Header", *header);
  if (!UnitHeader->Empty())
  W.WriteData("UnitHeader", *UnitHeader);

  W.WriteData("ElementContainerData", M.M);
}

template <class Read>
void ElementContainer::
NXread(Read &R) {
  R.ReadData("XKey", Xkey);
  R.ReadData("YKey", Ykey);
  R.ReadData("EKey", Ekey);

  R.ReadData("ElementContainerData", M.M);

  NXname _name, _class;
  int _id, _status;
  while ((_status=R.GetNextEntry2(_name, _class, &_id))==1) {
//      std::cerr << "NEXTENTRY: " << _name << "," << _class << ", "
//                        << _id << "," << _status << std::endl;
        if (strcmp(_name, "Header")==0)
          R.ReadData("Header", *header);
        else if (strcmp(_name, "UnitHeader")==0)
          R.ReadData("UnitHeader", *UnitHeader);
  }

}

#endif