snl_fei_LinearSystem_General.hpp

/*--------------------------------------------------------------------*/
/*    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_