diff.h

/*
 *  Definition of Lorene class Diff.
 *
 */

/*
 *   Copyright (c) 2005 Jerome Novak
 *
 *   This file is part of LORENE.
 *
 *   LORENE is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License version 2
 *   as published by the Free Software Foundation.
 *
 *   LORENE 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 LORENE; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#ifndef __DIFF_H_ 
#define __DIFF_H_ 

/*
 * $Id: diff.h,v 1.3 2006/04/10 15:20:51 j_novak Exp $
 * $Log: diff.h,v $
 * Revision 1.3  2006/04/10 15:20:51  j_novak
 * Operators dsdx and sx can now be used in the nucleus.
 *
 * Revision 1.2  2005/01/11 15:16:58  j_novak
 * More Diff operators.
 *
 * Revision 1.1  2005/01/10 16:39:21  j_novak
 * New class for 1D mono-domain differential operators.
 *
 *
 *
 * $Header: /cvsroot/Lorene/C++/Include/diff.h,v 1.3 2006/04/10 15:20:51 j_novak Exp $
 *
 */

#include "type_parite.h"
#include "matrice.h"

class Diff {

    // Data : 
    // -----
 public:
    static const int max_points = 50 ; 

 protected:
    int base ; 
    int npoints ; 

    // Constructors - Destructor
    // -------------------------
 protected:
    Diff(int base_r, int nr) ;  
    Diff(const Diff& ) ;        

    virtual ~Diff() ;           
 

    // Mutators / assignment
    // ---------------------
 protected:
    void operator=(const Diff&) ;   
    
    // Accessors
    // ---------
 public:
    int get_base() const {return base ;} ;

    int get_npoints() const { return npoints ;} ;

    operator Matrice() const { return get_matrice() ; }
    
    // Computational routines
    //-----------------------
 public:
    virtual const Matrice& get_matrice() const = 0 ;

    // Outputs
    // -------
 public:
    friend ostream& operator<<(ostream& , const Diff& ) ;   
    
 protected:
    virtual ostream& operator>>(ostream&) const = 0 ;

};


class Diff_dsdx : public Diff {

    // Constructors - Destructor
    // -------------------------
 public:
    Diff_dsdx(int base_r, int nr) ;  

    Diff_dsdx(const Diff_dsdx& ) ;   

    virtual ~Diff_dsdx() ;          

 private:
    void initialize() ;  
 
    // Mutators / assignment
    // ---------------------
 public:
    void operator=(const Diff_dsdx&) ;  
    
    // Computational routines
    //-----------------------
 public:
    virtual const Matrice& get_matrice() const ;

    // Outputs
    // -------
 protected:
    virtual ostream& operator>>(ostream&) const ;
};


class Diff_dsdx2 : public Diff {

    // Constructors - Destructor
    // -------------------------
 public:
    Diff_dsdx2(int base_r, int nr) ;     
    Diff_dsdx2(const Diff_dsdx2& ) ;     

    virtual ~Diff_dsdx2() ;         

 private:
    void initialize() ;  
 
    // Mutators / assignment
    // ---------------------
 public:
    void operator=(const Diff_dsdx2&) ; 
    
    // Computational routines
    //-----------------------
 public:
    virtual const Matrice& get_matrice() const ;

    // Outputs
    // -------
 protected:
    virtual ostream& operator>>(ostream&) const ;
};

class Diff_id : public Diff {

    // Constructors - Destructor
    // -------------------------
 public:
    Diff_id(int base_r, int nr) ;    
    Diff_id(const Diff_id& ) ;   

    virtual ~Diff_id() ;            

 private:
    void initialize() ;  
 
    // Mutators / assignment
    // ---------------------
 public:
    void operator=(const Diff_id&) ;    
    
    // Computational routines
    //-----------------------
 public:
    virtual const Matrice& get_matrice() const ;

    // Outputs
    // -------
 protected:
    virtual ostream& operator>>(ostream&) const ;
};

class Diff_mx : public Diff {

    // Constructors - Destructor
    // -------------------------
 public:
    Diff_mx(int base_r, int nr) ;    
    Diff_mx(const Diff_mx& ) ;   

    virtual ~Diff_mx() ;            

 private:
    void initialize() ;  
 
    // Mutators / assignment
    // ---------------------
 public:
    void operator=(const Diff_mx&) ;    
    
    // Computational routines
    //-----------------------
 public:
    virtual const Matrice& get_matrice() const ;

    // Outputs
    // -------
 protected:
    virtual ostream& operator>>(ostream&) const ;
};

class Diff_mx2 : public Diff {

    // Constructors - Destructor
    // -------------------------
 public:
    Diff_mx2(int base_r, int nr) ;   
    Diff_mx2(const Diff_mx2& ) ;     

    virtual ~Diff_mx2() ;           

 private:
    void initialize() ;  
 
    // Mutators / assignment
    // ---------------------
 public:
    void operator=(const Diff_mx2&) ;   
    
    // Computational routines
    //-----------------------
 public:
    virtual const Matrice& get_matrice() const ;

    // Outputs
    // -------
 protected:
    virtual ostream& operator>>(ostream&) const ;
};

class Diff_sx : public Diff {

    // Constructors - Destructor
    // -------------------------
 public:
    Diff_sx(int base_r, int nr) ;    
    Diff_sx(const Diff_sx& ) ;   

    virtual ~Diff_sx() ;            

 private:
    void initialize() ;  
 
    // Mutators / assignment
    // ---------------------
 public:
    void operator=(const Diff_sx&) ;    
    
    // Computational routines
    //-----------------------
 public:
    virtual const Matrice& get_matrice() const ;

    // Outputs
    // -------
 protected:
    virtual ostream& operator>>(ostream&) const ;
};

class Diff_sx2 : public Diff {

    // Constructors - Destructor
    // -------------------------
 public:
    Diff_sx2(int base_r, int nr) ;   
    Diff_sx2(const Diff_sx2& ) ;     

    virtual ~Diff_sx2() ;           

 private:
    void initialize() ;  
 
    // Mutators / assignment
    // ---------------------
 public:
    void operator=(const Diff_sx2&) ;   
    
    // Computational routines
    //-----------------------
 public:
    virtual const Matrice& get_matrice() const ;

    // Outputs
    // -------
 protected:
    virtual ostream& operator>>(ostream&) const ;
};

class Diff_xdsdx : public Diff {

    // Constructors - Destructor
    // -------------------------
 public:
    Diff_xdsdx(int base_r, int nr) ;     
    Diff_xdsdx(const Diff_xdsdx& ) ;     

    virtual ~Diff_xdsdx() ;         

 private:
    void initialize() ;  
 
    // Mutators / assignment
    // ---------------------
 public:
    void operator=(const Diff_xdsdx&) ; 
    
    // Computational routines
    //-----------------------
 public:
    virtual const Matrice& get_matrice() const ;

    // Outputs
    // -------
 protected:
    virtual ostream& operator>>(ostream&) const ;
};

class Diff_sxdsdx : public Diff {

    // Constructors - Destructor
    // -------------------------
 public:
    Diff_sxdsdx(int base_r, int nr) ;    
    Diff_sxdsdx(const Diff_sxdsdx& ) ;   

    virtual ~Diff_sxdsdx() ;            

 private:
    void initialize() ;  
 
    // Mutators / assignment
    // ---------------------
 public:
    void operator=(const Diff_sxdsdx&) ;    
    
    // Computational routines
    //-----------------------
 public:
    virtual const Matrice& get_matrice() const ;

    // Outputs
    // -------
 protected:
    virtual ostream& operator>>(ostream&) const ;
};

class Diff_x2dsdx2 : public Diff {

    // Constructors - Destructor
    // -------------------------
 public:
    Diff_x2dsdx2(int base_r, int nr) ;   
    Diff_x2dsdx2(const Diff_x2dsdx2& ) ;     

    virtual ~Diff_x2dsdx2() ;           

 private:
    void initialize() ;  
 
    // Mutators / assignment
    // ---------------------
 public:
    void operator=(const Diff_x2dsdx2&) ;   
    
    // Computational routines
    //-----------------------
 public:
    virtual const Matrice& get_matrice() const ;

    // Outputs
    // -------
 protected:
    virtual ostream& operator>>(ostream&) const ;
};

class Diff_xdsdx2 : public Diff {

    // Constructors - Destructor
    // -------------------------
 public:
    Diff_xdsdx2(int base_r, int nr) ;    
    Diff_xdsdx2(const Diff_xdsdx2& ) ;   

    virtual ~Diff_xdsdx2() ;            

 private:
    void initialize() ;  
 
    // Mutators / assignment
    // ---------------------
 public:
    void operator=(const Diff_xdsdx2&) ;    
    
    // Computational routines
    //-----------------------
 public:
    virtual const Matrice& get_matrice() const ;

    // Outputs
    // -------
 protected:
    virtual ostream& operator>>(ostream&) const ;
};

class Diff_x2dsdx : public Diff {

    // Constructors - Destructor
    // -------------------------
 public:
    Diff_x2dsdx(int base_r, int nr) ;    
    Diff_x2dsdx(const Diff_x2dsdx& ) ;   

    virtual ~Diff_x2dsdx() ;            

 private:
    void initialize() ;  
 
    // Mutators / assignment
    // ---------------------
 public:
    void operator=(const Diff_x2dsdx&) ;    
    
    // Computational routines
    //-----------------------
 public:
    virtual const Matrice& get_matrice() const ;

    // Outputs
    // -------
 protected:
    virtual ostream& operator>>(ostream&) const ;
};

class Diff_x3dsdx : public Diff {

    // Constructors - Destructor
    // -------------------------
 public:
    Diff_x3dsdx(int base_r, int nr) ;    
    Diff_x3dsdx(const Diff_x3dsdx& ) ;   

    virtual ~Diff_x3dsdx() ;            

 private:
    void initialize() ;  
 
    // Mutators / assignment
    // ---------------------
 public:
    void operator=(const Diff_x3dsdx&) ;    
    
    // Computational routines
    //-----------------------
 public:
    virtual const Matrice& get_matrice() const ;

    // Outputs
    // -------
 protected:
    virtual ostream& operator>>(ostream&) const ;
};

class Diff_x3dsdx2 : public Diff {

    // Constructors - Destructor
    // -------------------------
 public:
    Diff_x3dsdx2(int base_r, int nr) ;   
    Diff_x3dsdx2(const Diff_x3dsdx2& ) ;     

    virtual ~Diff_x3dsdx2() ;           

 private:
    void initialize() ;  
 
    // Mutators / assignment
    // ---------------------
 public:
    void operator=(const Diff_x3dsdx2&) ;   
    
    // Computational routines
    //-----------------------
 public:
    virtual const Matrice& get_matrice() const ;

    // Outputs
    // -------
 protected:
    virtual ostream& operator>>(ostream&) const ;
};

class Diff_x4dsdx2 : public Diff {

    // Constructors - Destructor
    // -------------------------
 public:
    Diff_x4dsdx2(int base_r, int nr) ;   
    Diff_x4dsdx2(const Diff_x4dsdx2& ) ;     

    virtual ~Diff_x4dsdx2() ;           

 private:
    void initialize() ;  
 
    // Mutators / assignment
    // ---------------------
 public:
    void operator=(const Diff_x4dsdx2&) ;   
    
    // Computational routines
    //-----------------------
 public:
    virtual const Matrice& get_matrice() const ;

    // Outputs
    // -------
 protected:
    virtual ostream& operator>>(ostream&) const ;
};


#endif

---