ModalTools.h

// @HEADER
// *****************************************************************************
//                 Anasazi: Block Eigensolvers Package
//
// Copyright 2004 NTESS and the Anasazi contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
// This software is a result of the research described in the report
//
//     "A comparison of algorithms for modal analysis in the absence
//     of a sparse direct method", P. Arbenz, R. Lehoucq, and U. Hetmaniuk,
//     Sandia National Laboratories, Technical report SAND2003-1028J.
//
// It is based on the Epetra, AztecOO, and ML packages defined in the Trilinos
// framework ( http://trilinos.org/ ).
 
#ifndef MODAL_TOOLS_H
#define MODAL_TOOLS_H
 
#include "Epetra_ConfigDefs.h"
 
#include "Epetra_BLAS.h"
#include "Epetra_Comm.h"
#include "Epetra_LAPACK.h"
#include "Epetra_LocalMap.h"
#include "Epetra_Map.h"
#include "Epetra_MultiVector.h"
#include "Epetra_Operator.h"
#include "Epetra_Time.h"
#include "Epetra_Vector.h"
 
#include "FortranRoutines.h"
 
class ModalTools {
 
  private:
 
    const FortranRoutines callFortran;
    const Epetra_BLAS callBLAS;
    const Epetra_LAPACK callLAPACK;
 
    const Epetra_Comm &MyComm;
    const Epetra_Time MyWatch;
 
    double eps;
 
    double timeQtMult;
    double timeQMult;
    double timeProj_MassMult;
    double timeNorm_MassMult;
    double timeProj;
    double timeNorm;
 
    int numProj_MassMult;
    int numNorm_MassMult;
 
  public:
 
    ModalTools(const Epetra_Comm &_Comm);
 
    int makeSimpleLumpedMass(const Epetra_Operator *M, double *weight) const;
 
    int massOrthonormalize(Epetra_MultiVector &X, Epetra_MultiVector &MX,
                           const Epetra_Operator *M, const Epetra_MultiVector &Q, int howMany,
                           int type = 0, double *WS = 0, double kappa = 1.5625);
 
    void localProjection(int numRow, int numCol, int length,
                         double *U, int ldU, double *MatV, int ldV, 
                         double *UtMatV, int ldUtMatV, double *work) const;
 
    int directSolver(int, double*, int, double*, int, int&, double*, int, double*, int,
                     int = 0) const;
 
    double getTimeProj()  const { return timeProj; }
    double getTimeProj_QtMult()    const { return timeQtMult; }
    double getTimeProj_QMult()     const { return timeQMult; }
    double getTimeProj_MassMult()  const { return timeProj_MassMult; }
    int getNumProj_MassMult()      const { return numProj_MassMult; }
 
    double getTimeNorm()  const { return timeNorm; }
    double getTimeNorm_MassMult() const { return timeNorm_MassMult; }
    int getNumNorm_MassMult()     const { return numNorm_MassMult; }
 
};
 
 
#endif