TPZFrontSym.h

Go to the documentation of this file.

template<class TVar>
class TPZEqnArray;

#ifndef TPZFRONTSYM_H
#define TPZFRONTSYM_H

#ifdef USING_ATLAS
extern "C"{
#include <cblas.h>
};
#endif

#include <iostream>
#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include <fstream>

#include "pzmatrix.h"
#include "pzstack.h"
#include "pzvec.h"
#include "TPZFront.h"
#include "TPZFileEqnStorage.h"
#include "TPZStackEqnStorage.h"

template <class TVar>
class TPZFrontSym : public TPZFront<TVar> {
public:
                std::string GetMatrixType();
                
                static void main();
    ~TPZFrontSym();
    TPZFrontSym();
    
    TPZFrontSym(const TPZFrontSym<TVar> &cp) : TPZRegisterClassId(&TPZFrontSym<TVar>::ClassId),
    TPZFront<TVar>(cp)
    {
    }
                TPZFrontSym(int64_t GlobalSize);
                
    virtual void SetDecomposeType(DecomposeType dectype) override
    {
        if (dectype == ECholesky || dectype == ELDLt) {
            this->fDecomposeType = dectype;
        }
        else
        {
            DebugStop();
        }
    }
    

    void DecomposeEquations(int64_t mineq, int64_t maxeq, TPZEqnArray<TVar> & result);
                
    void SymbolicDecomposeEquations(int64_t mineq, int64_t maxeq);
                
                void SymbolicAddKel(TPZVec < int64_t > & destinationindex);
                
    void Compress();
                
                void Expand(int largefrontsize);
                
                TVar & Element(int64_t i, int64_t j){
                                if(i>j){
                                                int64_t i_temp=i;
                                                i=j;
                                                j=i_temp;
                                }
                                return this->fData[(j*(j+1))/2+i];
                }
    const TVar & Element(int64_t i, int64_t j) const {
        if(i>j){
            int64_t i_temp=i;
            i=j;
            j=i_temp;
        }
        return this->fData[(j*(j+1))/2+i];
    }
    void AddKel(TPZFMatrix<TVar> &elmat, TPZVec<int64_t> &destinationindex);
                
    virtual void AddKel(TPZFMatrix<TVar> &elmat, TPZVec<int64_t> &sourceindex,  TPZVec<int64_t> &destinationindex);
                
                virtual void ExtractFrontMatrix(TPZFMatrix<TVar> &front) override;
        
        public:
int ClassId() const override;
                
private:    

                TVar & Element4JGreatEqualI(int64_t i, int64_t j){
#ifdef PZDEBUG
    if(i>j){
      DebugStop();
    }
#endif
                  return this->fData[(j*(j+1))/2+i];
  }
                
                
    void DecomposeOneEquation(int64_t ieq, TPZEqnArray<TVar> &eqnarray);
                
    void FreeGlobal(int64_t global);
    int Local(int64_t global);
public:
                virtual int64_t NFree() override;
                void Reset(int64_t GlobalSize=0);
                void AllocData();
                
                void Print(const char *name, std::ostream& out=std::cout) const;
                void PrintGlobal(const char *name, std::ostream& out = std::cout);
                
                DecomposeType GetDecomposeType() const;
                
                virtual void TensorProductIJ(int ithread, typename TPZFront<TVar>::STensorProductMTData *data) override;
                
    /*#  TPZFileEqnStorage lnkTPZFileEqnStorage; */
                
    /*#  TPZStackEqnStorage lnkTPZStackEqnStorage; */
};

#endif //TPZFRONTSYM_H