pzanalysis.h

Go to the documentation of this file.

#ifndef ANALYSISH
#define ANALYSISH

#include <iostream>           // for string, cout, ostream
#include <set>                // for set
#include "TPZGuiInterface.h"  // for TPZGuiInterface
#include "pzerror.h"          // for DebugStop
#include "pzmatrix.h"         // for TPZFMatrix, TPZMatrix
#include "pzreal.h"           // for STATE, REAL
#include "TPZRenumbering.h"    // for TPZRenumbering
#include "pzstrmatrix.h"      // for TPZStructMatrix
#include "pzvec.h"            // for TPZVec
#include "tpzautopointer.h"   // for TPZAutoPointer
class TPZCompEl;
class TPZCompMesh;
class TPZConnect;
class TPZGeoMesh;
class TPZGraphMesh;
template <class TVar> class TPZMatrixSolver;

class TPZAnalysis : public TPZSavable {
                
public:
                
                enum EPrecond { EJacobi, EBlockJacobi, EElement, ENodeCentered };
                
                
protected:
                TPZGeoMesh *fGeoMesh;
                TPZCompMesh *fCompMesh;
                TPZGraphMesh *fGraphMesh[3];
                TPZFMatrix<STATE> fRhs;
                TPZFMatrix<STATE> fSolution;
                TPZMatrixSolver<STATE> *fSolver;
                TPZVec<std::string> fScalarNames[3];
                TPZVec<std::string> fVectorNames[3];
    TPZVec<std::string> fTensorNames[3];
                int fStep;
                REAL fTime;
                
    int fNthreadsError;
    
                TPZAutoPointer<TPZStructMatrix>  fStructMatrix;
                
                TPZAutoPointer<TPZRenumbering> fRenumber;
                
                TPZAutoPointer<TPZGuiInterface> fGuiInterface;
                
                class TTablePostProcess : public TPZSavable {
        public :
                                TPZVec<int64_t> fGeoElId;
                                TPZVec<TPZCompEl *> fCompElPtr;
                                int fDimension;
                                TPZVec<REAL> fLocations;
                                TPZVec<std::string> fVariableNames;
                                TTablePostProcess();
                                ~TTablePostProcess();
                
                int ClassId() const override;
                
                void Write(TPZStream &buf, int withclassid) const override;

                void Read(TPZStream &buf, void *context) override;
                };
                
        TTablePostProcess fTable;
        
                public :
                
    std::function<void (const TPZVec<REAL> &loc, TPZVec<STATE> &result, TPZFMatrix<STATE> &deriv)> fExact;
                
                TPZAnalysis(TPZCompMesh *mesh, bool mustOptimizeBandwidth = true, std::ostream &out = std::cout);
                
                TPZAnalysis(TPZAutoPointer<TPZCompMesh> mesh, bool mustOptimizeBandwidth = true, std::ostream &out = std::cout);
    
                void SetGuiInterface(TPZAutoPointer<TPZGuiInterface> gui){
                                fGuiInterface = gui;
                }
                
                TPZAutoPointer<TPZGuiInterface> GetGuiInterface() const{
                                return fGuiInterface;
                }
                
                bool AmIKilled(){
                                if(fGuiInterface){
                                                return fGuiInterface->AmIKilled();
                                }
                                else return false;
                }
                
                virtual void SetCompMesh(TPZCompMesh * mesh, bool mustOptimizeBandwidth);
                
                TPZAnalysis();
        
        void Write(TPZStream &buf, int withclassid) const override;

        void Read(TPZStream &buf, void *context) override;
                
                virtual ~TPZAnalysis(void);
    
    void CleanUp();
    
    void SetRenumber(TPZAutoPointer<TPZRenumbering> renumber)
    {
        fRenumber = renumber;
    }
    
                void OptimizeBandwidth();
                
                int HighestDimension();
                
                void Resequence(int firstel = -1);
    
    int ComputeNumberofLoadCases();
    
                
                virtual  void Assemble();
                
                virtual void AssembleResidual();
                
                virtual void Solve();
                
                TPZFMatrix<STATE> &Rhs() { return fRhs;}

                TPZFMatrix<STATE> &Solution() { return fSolution;}
                
                TPZCompMesh *Mesh()const { return fCompMesh;}
                TPZAutoPointer<TPZStructMatrix> StructMatrix() {
        if(!fStructMatrix)
        {
            DebugStop();
        }
        return fStructMatrix;
    }
                
                TPZMatrixSolver<STATE> *BuildPreconditioner(EPrecond preconditioner, bool overlap);
                
    void SetStep(int step)
    {
        fStep = step;
    }
    
    void SetThreadsForError(int nthreads)
    {
        fNthreadsError = nthreads;
    }
    
    int GetStep()
    {
        return fStep;
    }
    
                void SetTime(REAL time);
                REAL GetTime();
                
private:
                
                TPZMatrixSolver<STATE> *BuildSequenceSolver(TPZVec<int64_t> &graph, TPZVec<int64_t> &graphindex, int64_t neq, int numcolors, TPZVec<int> &colors);

public:
                void ShowShape(const std::string &plotfile, TPZVec<int64_t> &equationindices);
    void ShowShape(const std::string &plotfile, TPZVec<int64_t> &equationindices, int matid, const TPZVec<std::string> &varname);
                void LoadShape(double dx,double dy, int64_t numelem,TPZConnect* nod);
                
                virtual void Run(std::ostream &out = std::cout);
                virtual void DefineGraphMesh(int dimension, const TPZVec<std::string> &scalnames, const TPZVec<std::string> &vecnames, const std::string &plotfile);
    virtual void DefineGraphMesh(int dimension, const TPZVec<std::string> &scalnames, const TPZVec<std::string> &vecnames, const TPZVec<std::string> &tensnames, const std::string &plotfile);
    virtual void DefineGraphMesh(int dimension, const std::set<int> & matids ,const TPZVec<std::string> &scalnames, const TPZVec<std::string> &vecnames, const std::string &plotfile);
    virtual void DefineGraphMesh(int dimension, const std::set<int> & matids, const TPZVec<std::string> &scalnames, const TPZVec<std::string> &vecnames, const TPZVec<std::string> &tensnames, const std::string &plotfile);
    
                virtual void CloseGraphMesh();
                
                TPZGraphMesh *GraphMesh(int dimension) {
                                return fGraphMesh[dimension-1];
                }
                virtual void PostProcess(int resolution);
                virtual void PostProcess(int resolution, int dimension);
                
    void IdentifyPostProcessingMatIds(int dimension, std::set<int> & matids);
    
    
                virtual void DefineElementTable(int dimension, TPZVec<int64_t> &GeoElIds, TPZVec<REAL> &points);
                virtual void SetTableVariableNames(TPZVec<std::string> varnames);
                virtual void PrePostProcessTable(std::ostream &out_file);
                virtual void PostProcessTable(std::ostream &out_file);

    
                void PostProcessTable(  TPZFMatrix<REAL> &pos,std::ostream &out= std::cout );

                virtual void LoadSolution();
                virtual void LoadSolution(const TPZFMatrix<STATE> &sol){
                                fSolution = sol;
                                this->LoadSolution();
                }

    TPZVec<STATE> Integrate(const std::string &varname, const std::set<int> &matids);
    
    void SetExact(std::function<void (const TPZVec<REAL> &loc, TPZVec<STATE> &result, TPZFMatrix<STATE> &deriv)> f);
                virtual void PostProcess(TPZVec<REAL> &loc, std::ostream &out = std::cout);
    
    virtual void PostProcessError(TPZVec<REAL> &, bool store_error = true, std::ostream &out = std::cout);
    
    virtual void PostProcessErrorSerial(TPZVec<REAL> &, bool store_error = true, std::ostream &out = std::cout);
    
    virtual void PostProcessErrorParallel(TPZVec<REAL> &, bool store_error = true, std::ostream &out = std::cout);
    
    void CreateListOfCompElsToComputeError(TPZAdmChunkVector<TPZCompEl *> &elvec);
                
                void Print( const std::string &name , std::ostream &out );
    
    void PrintVectorByElement(std::ostream &out, TPZFMatrix<STATE> &vec, REAL tol = 1.e-10);
    
                TPZMatrixSolver<STATE> & Solver();
                void AnimateRun(int64_t num_iter, int steps,
                                                                                TPZVec<std::string> &scalnames, TPZVec<std::string> &vecnames, const std::string &plotfile);
                void SetSolver(TPZMatrixSolver<STATE> &solver);
                void SetStructuralMatrix(TPZAutoPointer<TPZStructMatrix> strmatrix);
                void SetStructuralMatrix(TPZStructMatrix &strmatrix);
  
    public:
int ClassId() const override;

  struct ThreadData{
    
    TPZAdmChunkVector<TPZCompEl *> fElvec;
    
      ThreadData(TPZAdmChunkVector<TPZCompEl *> &elvec, bool store_error, std::function<void (const TPZVec<REAL> &loc, TPZVec<STATE> &result, TPZFMatrix<STATE> &deriv)> f);
    
    ~ThreadData();
    
    static void *ThreadWork(void *threaddata);
    
      std::function<void (const TPZVec<REAL> &loc, TPZVec<STATE> &result, TPZFMatrix<STATE> &deriv)> fExact;
    
    int64_t fNextElement;
    
    int ftid;
      
      bool fStoreError = false;
    
    // Vector with errors. Assuming no more than a 100 threads
    TPZManVector<TPZManVector<REAL,10>,100> fvalues;
    
    pthread_mutex_t fAccessElement;
    
    pthread_mutex_t fGetUniqueId;
    
  };
  
  friend struct ThreadData;
                
};


inline void

TPZAnalysis::SetExact(std::function<void (const TPZVec<REAL> &loc, TPZVec<STATE> &result, TPZFMatrix<STATE> &deriv)> f)
{
                fExact=f;
}

inline TPZMatrixSolver<STATE> &

TPZAnalysis::Solver(){
                return (*fSolver);
}

inline void TPZAnalysis::SetTime(REAL time){
                this->fTime = time;
}

inline REAL TPZAnalysis::GetTime(){
                return this->fTime;
}

#endif