FastMatrixElim.h

Go to the documentation of this file.

/**********************************************************************
** This program is part of 'MOOSE', the
** Messaging Object Oriented Simulation Environment.
**           Copyright (C) 2003-2013 Upinder S. Bhalla. and NCBS
** It is made available under the terms of the
** GNU Lesser General Public License version 2.1
** See the file COPYING.LIB for the full notice.
**********************************************************************/

class FastMatrixElim: public SparseMatrix< double >
{
    public:
        FastMatrixElim();
        FastMatrixElim( unsigned int nrows, unsigned int ncolumns );
        FastMatrixElim( const SparseMatrix< double >& orig );

        void makeTestMatrix( const double* test, unsigned int numCompts );

        void buildForwardElim( vector< unsigned int >& diag,
                vector< Triplet< double > >& fops );
        void buildBackwardSub( vector< unsigned int >& diag,
            vector< Triplet< double > >& bops, vector< double >& diagVal );
        // Here we do stuff to set up the Hines ordering of the matrix.

        bool hinesReorder( const vector< unsigned int >& parentVoxel,
                       vector< unsigned int >& lookupOldRowsFromNew );

        static void opsReorder(
                const vector< unsigned int >& lookupOldRowsFromNew,
                vector< Triplet< double > >& ops,
                vector< double >& diagVal );

        void shuffleRows(
                const vector< unsigned int >& lookupOldRowFromNew );

        bool checkSymmetricShape() const;

        bool operator==( const FastMatrixElim& other ) const;
        bool isSymmetric() const;

        void setDiffusionAndTransport(
            const vector< unsigned int >& parentVoxel,
            double diffConst, double motorConst, double dt );

        bool buildForDiffusion(
            const vector< unsigned int >& parentVoxel,
            const vector< double >& volume,
            const vector< double >& area,
            const vector< double >& length,
            double diffConst, double motorConst, double dt );

        static void advance( vector< double >& y,
            const vector< Triplet< double > >& ops, //has both fops and bops
            const vector< double >& diagVal );
};

void sortByColumn(
            vector< unsigned int >& col, vector< double >& entry );

// Todo: Maintain an internal vector of the mapping between rows so that
// the output vector can be updated in the right order, and input values
// can be mapped if matrix reassignment happens.
// The input to the parent class should just be a matrix with diameter
// and connectivity info, and then the system spawns out the ops
// vector depending on diffusion constant.