interface.hpp

#ifndef INTERFACE_G_H
#define INTERFACE_G_H

#include <list>

#include "iterators.hpp"
#include "mkl_matrix.hpp"

#include "rect_fwd.hpp"
#include <fstream>
#include <string>

/**************************
 *
 *  struct index_connector
 *
 *  Describes how indizes match
 *
 */

struct index_connector{    

    typedef STD_TR1::shared_ptr<index_connector> ref;

    typedef std::vector<int>::const_iterator const_iterator;

    const_iterator begin(){ return indizes.begin();};    
    const_iterator end(){ return indizes.end();};

    int operator()(const int i) const { return shift + indizes[i];};
    row operator()(const row i) const { return row(shift + indizes[i.get()]);};
    column operator()(const column i) const { return column(shift + indizes[i.get()]);};

    size_t size(){ return indizes.size();};

    size_t max_index(){ return (max + shift);};

    void debug_print(std::string name="index_connector");

private:
    friend class Interface;

    index_connector(size_t n, size_t s = 0): indizes(n,0), shift(0), max(0) {};

    void add_shift(size_t t){ shift += t;};

    void connect(size_t ind, int j);

    std::vector<int> indizes;
    size_t shift;
    int max;
};


/*****************************
 *
 *  class Interface_Matrix
 *
 *      Matrix class for connecting to few columns of a large matrix
 *  Describes how two matrices of different sizes are to be connected
 *
 */

class interface_Matrix: public Matrix{
public:

    interface_Matrix( Matrix* m,
              const index_connector::ref& i1, 
              const index_connector::ref& i2);

    virtual ~interface_Matrix() throw() {};

private:
    Matrix* my_mat;

    index_connector::ref row_connect;
    index_connector::ref column_connect;

    void insert(row r, column c, complex v);
    void add(row r, column c, complex v);
    complex get(row r, column c) const;
   
    size_t num_rows() const { return row_connect->size();};
    size_t num_cols() const { return column_connect->size();};
};


class Interface: public loadable_Object{

public:

    typedef STD_TR1::shared_ptr<Interface> ref;
    typedef STD_TR1::shared_ptr<const Interface> const_ref;

    static void
    reduce(const Matrix&,
       const index_connector::ref, 
       const index_connector::ref,
       mkl_Matrix&);

    static void
    reduce(const Vector&,
       const index_connector::ref,
       Vector&);
    static void 
    reduce(Vector&,
       const index_connector::ref);

    static void
    expand(const Vector&,
       const index_connector::ref,
       complex*);

    static index_connector::ref empty( size_t ny );

    virtual ~Interface() throw(){};
    
    index_connector::ref left() const;
    index_connector::ref right() const;

    double y_shift() const { return yshift();};

    void create_full_Interface(Matrix& m) const;

    void create_Hi(Matrix& m) const { createHi(m);};
    void create_Hit(Matrix& m) const { createHit(m);};

    void create_Hi_expand_left(Matrix& m) const;
    void create_Hi_expand_right(Matrix& m) const;
    void create_Hi_expand_both(Matrix& m) const;
    void create_Hit_expand_left(Matrix& m) const;
    void create_Hit_expand_right(Matrix& m) const;
    void create_Hit_expand_both(Matrix& m) const;

    mkl_Matrix::ref create_Hi() const { 
    mkl_Matrix::ref p(new rectangular_Matrix(row(n_left()),column(n_right())));
    createHi(*p); return p;
    };
    mkl_Matrix::ref create_Hi_expand_left() const { 
    mkl_Matrix::ref p(new rectangular_Matrix(row(n_right()),column(nleft_rect)));
    create_Hi_expand_left(*p); return p;
    };
    mkl_Matrix::ref create_Hi_expand_right() const { 
    mkl_Matrix::ref p(new rectangular_Matrix(row(nright_rect), column(n_left())));
    create_Hi_expand_right(*p); return p;
    };
    mkl_Matrix::ref create_Hi_expand_both() const { 
    mkl_Matrix::ref p(new rectangular_Matrix(row(nleft_rect),
                         column(nright_rect)));
    create_Hi_expand_both(*p); return p;
    };

    mkl_Matrix::ref create_Hit() const { 
    mkl_Matrix::ref p(new rectangular_Matrix(row(n_right()),column(n_left())));
    createHit(*p); return p;
    }
    mkl_Matrix::ref create_Hit_expand_left() const { 
    mkl_Matrix::ref p(new rectangular_Matrix(row(nleft_rect),column(n_right())));
    create_Hit_expand_left(*p); return p;
    };
    mkl_Matrix::ref create_Hit_expand_right() const { 
    mkl_Matrix::ref p(new rectangular_Matrix(row(n_left()), column(nright_rect)));
    create_Hit_expand_right(*p); return p;
    };
    mkl_Matrix::ref create_Hit_expand_both() const { 
    mkl_Matrix::ref p(new rectangular_Matrix(row(nright_rect),
                         column(nleft_rect)));
    create_Hit_expand_both(*p); return p;
    };

    size_t n_left() const { return nleft();};
    size_t n_right() const { return nright();};

    size_t n_left_rect() const { return nleft_rect;};
    size_t n_right_rect() const { return nright_rect;};

protected:

    Interface(){};

    static
    void connect_index(index_connector& v, size_t i, int j) 
    { v.connect( i, j);};

    void set_n_left_right(size_t nl, size_t nr) { nleft_rect = nl; nright_rect = nr;};

private:
    const char* name() const { return "Abstract_Interface";};

    size_t nleft_rect;
    size_t nright_rect;

    void init();
    virtual void init_interface_params() = 0;
    
    virtual void connect_left_indizes(index_connector&) const = 0;
    virtual void connect_right_indizes(index_connector&) const = 0;

    virtual void createHi(Matrix& m) const = 0;
    virtual void createHit(Matrix& m) const = 0;

    virtual double yshift() const = 0;

    virtual size_t nright() const = 0;
    virtual size_t nleft() const = 0;
};

#endif