ConstitutiveModel.hpp

Go to the documentation of this file.

//*****************************************************************//
//    Albany 2.0:  Copyright 2012 Sandia Corporation               //
//    This Software is released under the BSD license detailed     //
//    in the file "license.txt" in the top-level Albany directory  //
//*****************************************************************//

#if !defined(LCM_ConstitutiveModel_hpp)
#define LCM_ConstitutiveModel_hpp

#include "Phalanx_ConfigDefs.hpp"
#include "Phalanx_Evaluator_WithBaseImpl.hpp"
#include "Phalanx_Evaluator_Derived.hpp"
#include "Phalanx_MDField.hpp"
#include "Albany_Layouts.hpp"

namespace LCM
{

template<typename EvalT, typename Traits>
class ConstitutiveModel
{
public:

  typedef typename EvalT::ScalarT ScalarT;
  typedef typename EvalT::MeshScalarT MeshScalarT;

  ConstitutiveModel(Teuchos::ParameterList* p,
      const Teuchos::RCP<Albany::Layouts>& dl);

  virtual
  ~ConstitutiveModel()
  {};

  virtual
  void
  computeState(
      typename Traits::EvalData workset,
      std::map<std::string, Teuchos::RCP<PHX::MDField<ScalarT> > > dep_fields,
      std::map<std::string, Teuchos::RCP<PHX::MDField<ScalarT> > > eval_fields) = 0;

  void
  computeVolumeAverage(
      typename Traits::EvalData workset,
      std::map<std::string, Teuchos::RCP<PHX::MDField<ScalarT> > > dep_fields,
      std::map<std::string, Teuchos::RCP<PHX::MDField<ScalarT> > > eval_fields);

  std::map<std::string, Teuchos::RCP<PHX::DataLayout> >
  getDependentFieldMap()
  {
    return dep_field_map_;
  }

  std::map<std::string, Teuchos::RCP<PHX::DataLayout> >
  getEvaluatedFieldMap()
  {
    return eval_field_map_;
  }

  std::string getStateVarName(int state_var);
  Teuchos::RCP<PHX::DataLayout> getStateVarLayout(int state_var);
  std::string getStateVarInitType(int state_var);
  double getStateVarInitValue(int state_var);
  bool getStateVarOldStateFlag(int state_var);
  bool getStateVarOutputFlag(int state_var);

  int getNumStateVariables()
  {
    return num_state_variables_;
  }

  bool
  getIntegrationPointLocationFlag()
  {
    return need_integration_pt_locations_;
  }

  void
  setCoordVecField(PHX::MDField<MeshScalarT, Cell, QuadPoint, Dim> coord_vec)
  {
    coord_vec_ = coord_vec;
  }

  void
  setTemperatureField(PHX::MDField<ScalarT, Cell, QuadPoint> temperature)
  {
    temperature_ = temperature;
  }

  void
  setDamageField(PHX::MDField<ScalarT, Cell, QuadPoint> damage)
  {
    damage_ = damage;
  }

  void
  setWeightsField(PHX::MDField<MeshScalarT, Cell, QuadPoint> weights)
  {
    weights_ = weights;
  }

protected:

  int num_state_variables_;

  std::size_t num_dims_;

  std::size_t num_pts_;

  bool need_integration_pt_locations_;

  bool compute_energy_;

  bool compute_tangent_;

  bool have_temperature_;

  bool have_damage_;

  PHX::MDField<MeshScalarT, Cell, QuadPoint, Dim> coord_vec_;

  PHX::MDField<ScalarT, Cell, QuadPoint> temperature_;

  PHX::MDField<ScalarT, Cell, QuadPoint> damage_;

  PHX::MDField<MeshScalarT, Cell, QuadPoint> weights_;

  Teuchos::RCP<std::map<std::string, std::string> > field_name_map_;

  std::vector<std::string> state_var_names_;
  std::vector<Teuchos::RCP<PHX::DataLayout> > state_var_layouts_;
  std::vector<std::string> state_var_init_types_;
  std::vector<double> state_var_init_values_;
  std::vector<bool> state_var_old_state_flags_;
  std::vector<bool> state_var_output_flags_;

  std::map<std::string, Teuchos::RCP<PHX::DataLayout> > dep_field_map_;
  std::map<std::string, Teuchos::RCP<PHX::DataLayout> > eval_field_map_;

  RealType expansion_coeff_;

  RealType ref_temperature_;

  RealType heat_capacity_;

  RealType density_;

private:
  ConstitutiveModel(const ConstitutiveModel&);

  ConstitutiveModel& operator=(const ConstitutiveModel&);

};
}

#endif