snl_fei_LinearSystem_FEData.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_FEData_hpp_
#define _snl_fei_LinearSystem_FEData_hpp_
 
#include <fei_macros.hpp>
#include <fei_mpi.h>
#include <fei_utils.hpp>
#include <fei_LinearSystem.hpp>
#include <fei_Vector.hpp>
#include <fei_Matrix.hpp>
#include <fei_fwd.hpp>
 
namespace fei {
  class DirichletBCManager;
}
 
namespace snl_fei {
  class LinearSystem_FEData : public fei::LinearSystem {
  public:
    LinearSystem_FEData(fei::SharedPtr<FiniteElementData>& fedata,
      fei::SharedPtr<fei::MatrixGraph>& matrixGraph);

    virtual ~LinearSystem_FEData();

    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);

    fei::SharedPtr<FiniteElementData> getFiniteElementData() { return( feData_ ); }

    int parameters(int numParams,
       const char* const* paramStrings)
      { return( feData_->parameters(numParams, (char**)paramStrings) ); }

    int parameters(const fei::ParameterSet& params)
      {
  int numParams = 0;
  const char** paramStrings = NULL;
  std::vector<std::string> stdstrings;
  fei::utils::convert_ParameterSet_to_strings(&params, stdstrings);
  fei::utils::strings_to_char_ptrs(stdstrings, numParams, paramStrings);
 
  int err = parameters(numParams, paramStrings);
 
  delete [] paramStrings;
 
  return(err);
      }

    int setBCValuesOnVector(fei::Vector* vector);

    void setLookup(Lookup* lookup)
      { lookup_ = lookup; }

    bool eqnIsEssentialBC(int globalEqnIndex) const;

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

    void getConstrainedEqns(std::vector<int>& crEqns) const;
 
  private:
    int implementBCs(bool applyBCs);
 
    MPI_Comm comm_;
    int localProc_;
    int numProcs_;
    fei::SharedPtr<fei::Matrix> matrix_;
    fei::SharedPtr<fei::Vector> soln_;
    fei::SharedPtr<fei::Vector> rhs_;
    fei::SharedPtr<FiniteElementData> feData_;
    Lookup* lookup_;
 
    std::vector<char*> attributeNames_;
    std::vector<void*> attributes_;
  };//class LinearSystem_FEData
}//namespace snl_fei
 
#endif // _snl_fei_LinearSystem_FEData_hpp_