snl_fei_LinearSystem_General.hpp

Go to the documentation of this file.

/*--------------------------------------------------------------------*/
/*    Copyright 2005 Sandia Corporation.                              */
/*    Under the terms of Contract DE-AC04-94AL85000, there is a       */
/*    non-exclusive license for use of this work by or on behalf      */
/*    of the U.S. Government.  Export of this program may require     */
/*    a license from the United States Government.                    */
/*--------------------------------------------------------------------*/
 
#ifndef _snl_fei_LinearSystem_General_hpp_
#define _snl_fei_LinearSystem_General_hpp_
 
#include <fei_macros.hpp>
#include <fei_mpi.h>
#include <fei_CSVec.hpp>
#include <fei_LinearSystem.hpp>
#include <fei_Matrix.hpp>
#include <fei_Vector.hpp>
#include <fei_fwd.hpp>
#include <fei_Logger.hpp>
 
namespace fei {
  class DirichletBCManager;
}
 
namespace snl_fei {
  class LinearSystem_General : public fei::LinearSystem,
                               private fei::Logger {
  public:
    LinearSystem_General(fei::SharedPtr<fei::MatrixGraph>& matrixGraph);

    virtual ~LinearSystem_General();

    int loadEssentialBCs(int numIDs,
                         const int* IDs,
                         int idType,
                         int fieldID,
                         int offsetIntoField,
                         const double* prescribedValues);

    int loadEssentialBCs(int numIDs,
                         const int* IDs,
                         int idType,
                         int fieldID,
                         const int* offsetIntoField,
                         const double* prescribedValues);

    int loadLagrangeConstraint(int constraintID,
             const double *weights,
             double rhsValue);

    int loadPenaltyConstraint(int constraintID,
            const double *weights,
            double penaltyValue,
            double rhsValue);

    int loadComplete(bool applyBCs=true,
                     bool globalAssemble=true);

    int parameters(int numParams,
       const char* const* paramStrings);

    int parameters(const fei::ParameterSet& params);

    int setBCValuesOnVector(fei::Vector* vector);

    bool eqnIsEssentialBC(int globalEqnIndex) const;

    void getEssentialBCs(std::vector<int>& bcEqns,
                         std::vector<double>& bcVals) const;

    void getConstrainedEqns(std::vector<int>& crEqns) const;
 
  private:
    void setName(const char* name);
 
    int fill_EssBCValues();
 
    int implementBCs(bool applyBCs);
 
    int enforceEssentialBC_LinSysCore();
 
    void enforceEssentialBC_step_1(fei::CSVec& essBCs);
 
    void enforceEssentialBC_step_2(fei::CSVec& essBCs);
 
    int getMatrixRow(fei::Matrix* matrix, int row,
         std::vector<double>& coefs,
         std::vector<int>& indices);
 
    MPI_Comm comm_;
 
    fei::CSVec* essBCvalues_;
    fei::CSVec* allEssBCs_;
 
    bool resolveConflictRequested_;
    bool bcs_trump_slaves_;
    bool explicitBCenforcement_;
    bool BCenforcement_no_column_mod_;
 
    int localProc_;
    int numProcs_;
 
    int firstLocalOffset_;
    int lastLocalOffset_;
 
    std::string name_;
    std::map<std::string, unsigned> named_loadcomplete_counter_;
 
    std::vector<int> iwork_;
    std::vector<double> dwork_;
    std::string dbgprefix_;
  };//class LinearSystem_General
}//namespace snl_fei
 
#endif // _snl_fei_LinearSystem_General_hpp_