luft.h

Go to the documentation of this file.

//  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *  //
//                                                                                   //
//                       / /   / /    __    \ \  / /                                 //
//                      / /__ / /   / _ \    \ \/ /                                  //
//                     /  ___  /   | |/_/    / /\ \                                  //
//                    / /   / /    \_\      / /  \ \                                 //
//                                                                                   //
//                                                                                   //
//  Copyright (c) 2016, Jakub Benda, Charles University in Prague                    //
//                                                                                   //
// MIT License:                                                                      //
//                                                                                   //
//  Permission is hereby granted, free of charge, to any person obtaining a          //
// copy of this software and associated documentation files (the "Software"),        //
// to deal in the Software without restriction, including without limitation         //
// the rights to use, copy, modify, merge, publish, distribute, sublicense,          //
// and/or sell copies of the Software, and to permit persons to whom the             //
// Software is furnished to do so, subject to the following conditions:              //
//                                                                                   //
//  The above copyright notice and this permission notice shall be included          //
// in all copies or substantial portions of the Software.                            //
//                                                                                   //
//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS          //
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       //
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE       //
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, //
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF         //
// OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  //
//                                                                                   //
//  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *  //

#ifndef HEX_LUFT_H
#define HEX_LUFT_H

// --------------------------------------------------------------------------------- //

#include "hex-arrays.h"
#include "hex-rts.h"

// --------------------------------------------------------------------------------- //

template <class IdxT, class DataT> class CsrMatrix;

// --------------------------------------------------------------------------------- //

typedef struct
{
    Real drop_tolerance;
    bool out_of_core;
    int verbosity;
    int fortran_comm;
    int groupsize;
    const char * ooc_dir;
    void * superlu_dist_grid;
    bool centralized_matrix;
}
LUftData;

// --------------------------------------------------------------------------------- //

extern LUftData defaultLUftData;

// --------------------------------------------------------------------------------- //

class LUft
{
    public:
        
        //
        // Run-time selection mechanism (object factory).
        //
        
            baseClassRunTimeSelectionDefinitions(LUft, ())
        
        //
        // Class member functions.
        //
        
            
            LUft () : filename_() {}
            
            virtual ~LUft () {}
            
            virtual void factorize (CsrMatrix<LU_int_t,Complex> const & matrix, LUftData data = defaultLUftData) = 0;
            
            virtual bool valid () const { return false; }
            
            virtual void drop () {}
            
            virtual std::size_t size () const { return 0; }
            
            virtual Real cond () const { return 0; }
            
            virtual void solve (const cArrayView b, cArrayView x, int eqs) const = 0;
            
            virtual cArray solve (const cArrayView b, int eqs = 1) const
            {
                // reserve space for the solution
                cArray x (b.size());
                
                // solve
                this->solve(b, x, eqs);
                
                // return the result
                return x;
            }
            
            virtual void link (std::string name) { filename_ = name; }
            
            virtual void unlink () { filename_.clear(); }
            
            virtual std::string filename () const { return filename_; }
            
            virtual void save (std::string name) const = 0;
            virtual void save () const { this->save(filename_); }
            
            virtual void load (std::string name, bool throw_on_io_failure = true) = 0;
            virtual void load () { this->load(filename_, true); }
            virtual void silent_load () { this->load(filename_, false); }
        
    private:
        
        std::string filename_;
};

// --------------------------------------------------------------------------------- //

#define factorizerRunTimeSelectionDefinitions(TYPE,NAME) \
    derivedClassRunTimeSelectionDefinitions(LUft, (), TYPE, (), NAME)

// --------------------------------------------------------------------------------- //

#endif // HEX_LUFT_H