Data.h

Go to the documentation of this file.

/********************************************************************
 *  Copyright (C) 2014 by Federico Marulli and Alfonso Veropalumbo  *
 *  federico.marulli3@unibo.it                                      *
 *                                                                  *
 *  This program is free software; you can redistribute it and/or   *
 *  modify it under the terms of the GNU General Public License as  *
 *  published by the Free Software Foundation; either version 2 of  *
 *  the License, or (at your option) any later version.             *
 *                                                                  *
 *  This program is distributed in the hope that it will be useful, *
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of  *
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the   *
 *  GNU General Public License for more details.                    *
 *                                                                  *
 *  You should have received a copy of the GNU General Public       *
 *  License along with this program; if not, write to the Free      *
 *  Software Foundation, Inc.,                                      *
 *  59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.       *
 ********************************************************************/
 
#ifndef __DATA__
#define __DATA__
 
#include "Func.h"
 
namespace cbl {
 
  namespace data {
 
    enum class DataType { 
 
      _1D_,
 
      _2D_,
     
      _1D_collection_,
 
      _1D_extra_,
 
      _2D_extra_,
 
    };
 
    inline std::vector<std::string> DataTypeNames () { return {"1D", "2D", "1D_collection", "1D_extra", "2D_extra"}; }
  
    class Data
    {
      
    protected:
 
      DataType m_dataType;
 
      int m_ndata;
 
      std::vector<double> m_data;
      
      std::vector<double> m_error;
      
      std::vector<double> m_edges_xx;
      
      std::vector<double> m_edges_yy;
      
      std::vector<std::vector<double>> m_covariance;
      
      std::vector<std::vector<double>> m_inverse_covariance;
 
      void set_dataType (const DataType dataType) { m_dataType = dataType; } 
 
    public:
 
 
      Data () = default;
      
      Data (const DataType dataType) : m_dataType(dataType) {}
 
      Data (const DataType dataType, const int ndata)
    : m_dataType(dataType)
      { reset(ndata); }
 
      Data (const DataType dataType, const std::vector<double> data); 
 
      Data (const DataType dataType, const std::vector<double> data, const std::vector<double> error);
 
      Data (const DataType dataType, const std::vector<double> data, const std::vector<std::vector<double>> covariance);
 
      virtual ~Data () = default;
 
      static std::shared_ptr<Data> Create (const DataType dataType); 
 
      virtual std::shared_ptr<Data> as_factory () 
      { ErrorCBL("", "as_factory", "Data.h"); return NULL; }
 
 
      
      
      double correlation (const int i, const int j) const { return m_covariance[i][j]/sqrt(m_covariance[i][i]*m_covariance[j][j]); }
 
      std::vector<std::vector<double>> correlation () const;
      
      double inverse_covariance (const int i, const int j) const { return m_inverse_covariance[i][j]; }
 
      std::vector<std::vector<double>> inverse_covariance () const { return m_inverse_covariance; }
 
      void reset (const int ndata);
 
      virtual void invert_covariance (const double prec, const int Nres) { invert_matrix(m_covariance, m_inverse_covariance, prec, Nres); }
 
      
 
 
      virtual double xx (const int i) const
      { (void)i; ErrorCBL("", "xx", "Data.h"); return 0; } 
 
      virtual std::vector<double> xx () const 
      { ErrorCBL("", "xx", "Data.h"); return {}; } 
 
      virtual double xx (const int i, const int j) const
      { (void)i; (void)j; ErrorCBL("", "xx", "Data.h"); return 0.; }
 
      virtual double yy (const int i) const 
      { (void)i; ErrorCBL("", "yy", "Data.h"); return 0.; }
 
      virtual std::vector<double> yy () const 
      { ErrorCBL("", "yy", "Data.h"); return {}; } 
      
      virtual std::vector<std::vector<double>> IndipendentVariable(const int i=-1, const int j=-1) const
      { (void)i; (void)j; ErrorCBL("", "IndipendentVariable", "Data.h"); std::vector<std::vector<double>> pp; return {pp}; }
 
      virtual double data (const int i, const int j) const
      { (void)i; (void)j; ErrorCBL("", "data", "Data.h"); return 0.; }
 
      virtual void get_data (std::vector<double> &data) const
      { (void)data; ErrorCBL("", "data", "Data.h"); }
      
      virtual DataType dataType () const
      { return m_dataType; }
 
      virtual int ndata () const { return m_ndata; }
 
      virtual double data (const int i) const { return m_data[i]; }
 
      virtual std::vector<double> data () const { return m_data; }
 
      virtual double error (const int i) const { return m_error[i]; }
 
      virtual std::vector<double> error () const { return m_error; }
 
      virtual double covariance (const int i, const int j) const { return m_covariance[i][j]; }
 
      virtual std::vector<std::vector<double>> covariance () const { return m_covariance; }
      
      virtual double edges_xx (const int i) const { return m_edges_xx[i]; }
 
      virtual std::vector<double> edges_xx () const { return m_edges_xx; }
      
      virtual double edges_yy (const int i) const { return m_edges_yy[i]; }
 
      virtual std::vector<double> edges_yy () const { return m_edges_yy; }
 
      virtual void get_data (std::vector<std::vector<double>> &data) const
      { (void)data; ErrorCBL("", "data", "Data.h"); }
 
      virtual double error (const int i, const int j) const
      { (void)i; (void)j; ErrorCBL("", "error", "Data.h"); return 0.; } 
 
      virtual void get_error (std::vector<double> &error) const
      { (void)error; ErrorCBL("", "error", "Data.h"); }
 
      virtual void get_error (std::vector<std::vector<double>> &error) const
      { (void)error; ErrorCBL("", "error", "Data.h"); }
 
      virtual double extra_info (const int i, const int j) const
      { (void)i; (void)j; ErrorCBL("", "extra_info", "Data.h"); return 0.; }
 
      virtual std::vector<std::vector<double>> extra_info () const
      { ErrorCBL("", "extra_info", "Data.h"); std::vector<std::vector<double>> x; return x; }
      
 
 
      virtual void set_xx (const std::vector<double> x)
      { (void)x; ErrorCBL("", "set_xx", "Data.h"); }
 
      virtual void set_yy (const std::vector<double> y)
      { (void)y; ErrorCBL("", "set_yy", "Data.h"); }
 
      virtual void set_xx (const int i, const std::vector<double> x) 
      { (void)i; (void)x; ErrorCBL("", "set_xx", "Data.h"); }
 
      virtual void set_xx (const std::vector<std::vector<double>> x)
      { (void)x; ErrorCBL("", "set_xx", "Data.h"); }
      
      virtual void set_edges_xx (const std::vector<double> edges)
      { (void)edges; ErrorCBL("", "set_edges_xx", "Data.h"); }
      
      virtual void set_edges_yy (const std::vector<double> edges)
      { (void)edges; ErrorCBL("", "set_edges_yy", "Data.h"); }
 
      virtual void set_data (const std::vector<std::vector<double>> data) 
      { (void)data; ErrorCBL("", "set_data", "Data.h"); }
 
      virtual void set_extra_info (const std::vector<std::vector<double>> extra_info)
      { (void)extra_info; ErrorCBL("", "set_extra_info", "Data.h"); }
 
      void set_data (const std::vector<double> data);
 
      void set_error (const std::vector<double> error);
 
      void set_error (const std::vector<std::vector<double>> covariance);
 
      void set_covariance (const std::string filename, const int cov_col=2, const int skipped_lines=0);
 
      void set_covariance (const double value, const int i, const int j) { m_covariance[i][j] = value; }
 
      void set_covariance (const std::vector<std::vector<double>> covariance);
 
      void set_covariance (const std::vector<double> error);
      
 
 
      virtual int ndata (const int i) const 
      { (void)i; return ErrorCBL("", "ndata", "Data.h"); }
 
      virtual int ndataset () const
      { return ErrorCBL("", "ndataset", "Data.h"); }
 
      virtual int xsize () const
      { return ErrorCBL("", "xsize", "Data.h"); }
 
      virtual int xsize (const int i) const
      { (void)i; return ErrorCBL("", "xsize", "Data.h"); }
 
      virtual int ysize () const
      { return ErrorCBL("", "ysize", "Data.h"); }
 
 
 
      
      virtual void read (const std::string input_file, const int skip_nlines=0, const std::vector<int> column={0}, const std::vector<int> column_data={}, const std::vector<int> column_errors={}, const std::vector<int> column_edges={})
      { (void)input_file; (void)skip_nlines; (void)column, (void)column_data, (void)column_errors, (void)column_edges, ErrorCBL("", "read", "Data.h"); }
 
      virtual void read (const std::vector<std::string> input_file, const int skip_nlines=0, const std::vector<int> column={0}, const std::vector<int> column_data={}, const std::vector<int> column_errors={}, const std::vector<int> column_edges={})
      { (void)input_file; (void)skip_nlines; (void)column, (void)column_data, (void)column_errors, (void)column_edges, ErrorCBL("", "read", "Data.h"); }
      
      virtual void Print (const int prec=4) const 
      { (void)prec; ErrorCBL("", "Print", "Data.h"); }
      
      virtual void write (const std::string dir, const std::string file, const std::string header, const int prec=4, const int ww=8, const int rank=0) const 
      { (void)dir; (void)file; (void)header; (void)prec; (void)ww; (void)rank; ErrorCBL("", "write", "Data.h"); }
 
      virtual void write (const std::string dir, const std::string file, const std::string header, const bool full, const int prec=10, const int ww=8, const int rank=0) const
      { (void)dir; (void)file; (void)header; (void)full; (void)prec; (void)ww; (void)rank; ErrorCBL("", "write", "Data.h"); }
 
      virtual void write (const std::string dir, const std::vector<std::string> files, const std::string header, const int prec=10, const int ww=8, const int rank=0) const
      { (void)dir; (void)files; (void)header; (void)prec; (void)ww; (void)rank; ErrorCBL("", "write", "Data.h"); }
      
      virtual void write_covariance (const std::string dir, const std::string file, const int precision=10) const
      { (void)dir; (void)file; (void)precision; ErrorCBL("", "write_covariance", "Data.h"); }
 
 
      
 
      void cut (const std::vector<bool> mask, std::vector<double> &data, std::vector<double> &error, std::vector<std::vector<double>> &covariance_matrix) const;
 
      virtual std::shared_ptr<Data> cut (const std::vector<bool> mask) const
      { (void)mask; ErrorCBL("", "cut", "Data.h"); std::shared_ptr<Data> dd; return dd; } 
 
      virtual std::shared_ptr<Data> cut (const double xmin, const double xmax) const
      { (void)xmin; (void)xmax; ErrorCBL("", "cut", "Data.h"); std::shared_ptr<Data> dd; return dd; } 
 
      virtual std::shared_ptr<Data> cut (const double xmin, const double xmax, const double ymin, const double ymax) const
      { (void)xmin; (void)xmax; (void)ymin; (void)ymax; ErrorCBL("", "cut", "Data.h"); std::shared_ptr<Data> dd; return dd; } 
 
      virtual std::shared_ptr<Data> cut (const int dataset, const double xmin, const double xmax) const
      { (void)dataset; (void)xmin; (void)xmax; ErrorCBL("", "cut", "Data.h"); std::shared_ptr<Data> dd; return dd; } 
 
      virtual std::shared_ptr<Data> cut (const std::vector<double> xmin, const std::vector<double> xmax) const
      { (void)xmin; (void)xmax; ErrorCBL("", "cut", "Data.h"); std::shared_ptr<Data> dd; return dd; } 
 
      
    };
    
 
    std::shared_ptr<data::Data> join_dataset (std::vector<std::shared_ptr<data::Data>> dataset);    
 
    std::shared_ptr<data::Data> join_dataset_1D (std::vector<std::shared_ptr<data::Data>> dataset); 
 
    std::shared_ptr<data::Data> join_dataset_1D_extra (std::vector<std::shared_ptr<data::Data>> dataset);   
 
  }
}
 
#endif