Albany_StateManager.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  //
//*****************************************************************//

#ifndef ALBANY_STATEMANAGER
#define ALBANY_STATEMANAGER

#include <string>
#include <map>
#include <vector>
#include "Epetra_Vector.h"
#include "Teuchos_RCP.hpp"
#include "Phalanx_DataLayout.hpp"
#include "Intrepid_FieldContainer.hpp"
#include "Albany_DataTypes.hpp"
#include "Teuchos_ParameterList.hpp"
#include "Albany_AbstractDiscretization.hpp"
#include "Albany_StateInfoStruct.hpp"
#include "Albany_EigendataInfoStruct.hpp"
#include "Adapt_NodalDataBlock.hpp"

namespace Albany {

/* \brief The usage is to register state variables that will be saved
 * during problem construction, where they are described by a string
 * and a DataLayout. One time, the allocate method is called, which 
 * creates the memory for a vector of worksets of these states, which
 * are stored as MDFields.
*/

class StateManager {
public:

  enum SAType {ELEM, NODE};

  StateManager ();

  ~StateManager () { };

  typedef std::map<std::string, Teuchos::RCP<PHX::DataLayout> >  RegisteredStates;

  void registerStateVariable(const std::string &stateName, 
           const Teuchos::RCP<PHX::DataLayout> &dl,
                             const std::string &ebName,
           const std::string &init_type="scalar",
           const double init_val=0.0,
           const bool registerOldState=false,
           const bool outputToExodus=true,
           const std::string &responseIDtoRequire="");

  Teuchos::RCP<Teuchos::ParameterList>
  registerStateVariable(const std::string &name, const Teuchos::RCP<PHX::DataLayout> &dl, 
                        const Teuchos::RCP<PHX::DataLayout> &dummy,
                        const std::string &ebName,
                        const std::string &init_type="scalar",
                        const double init_val=0.0,
                        const bool registerOldState=false);

  Teuchos::RCP<Teuchos::ParameterList>
  registerStateVariable(const std::string &stateName, const Teuchos::RCP<PHX::DataLayout> &dl, 
      const Teuchos::RCP<PHX::DataLayout> &dummy,
                        const std::string &ebName,
      const std::string &init_type,
                        const double init_val,
                        const bool registerOldState,
      const std::string &fieldName);

  Teuchos::RCP<Teuchos::ParameterList>
  registerStateVariable(const std::string &stateName, const Teuchos::RCP<PHX::DataLayout> &dl, 
      const Teuchos::RCP<PHX::DataLayout> &dummy,
                        const std::string &ebName,
      const std::string &init_type,
                        const double init_val,
                        const bool registerOldState,
      const bool outputToExodus);

  void
  registerStateVariable(const std::string &stateName, const Teuchos::RCP<PHX::DataLayout> &dl, 
      const std::string &init_type);


  void importStateData(Albany::StateArrays& statesToCopyFrom);

  std::map<std::string, RegisteredStates>& getRegisteredStates(){return statesToStore;}

  std::vector<std::string> getResidResponseIDsToRequire(std::string & elementBlockName);

  void updateStates();

  Teuchos::RCP<Albany::StateInfoStruct> getStateInfoStruct();

  void setStateArrays(const Teuchos::RCP<Albany::AbstractDiscretization>& discObj);

  Teuchos::RCP<Albany::AbstractDiscretization> getDiscretization();

  Albany::StateArray& getStateArray(SAType type, int ws) const;
  Albany::StateArrays& getStateArrays() const;

  Teuchos::RCP<Adapt::NodalDataBlock> getNodalDataBlock(){ return stateInfo->createNodalDataBlock(); }
  
  Teuchos::RCP<Albany::EigendataStruct> getEigenData();
  void setEigenData(const Teuchos::RCP<Albany::EigendataStruct>& eigdata);

  Teuchos::RCP<Epetra_MultiVector> getAuxData();
  void setAuxData(const Teuchos::RCP<Epetra_MultiVector>& aux_data);


private:
  StateManager(const StateManager&);

  StateManager& operator=(const StateManager&);

private:

  bool stateVarsAreAllocated;

  std::map<std::string, RegisteredStates> statesToStore;

  Teuchos::RCP<Albany::AbstractDiscretization> disc;

  Teuchos::RCP<StateInfoStruct> stateInfo;
  Teuchos::RCP<EigendataStruct> eigenData;
  Teuchos::RCP<Epetra_MultiVector> auxData;

  // Experiment in dealing with Time
  double time;
  double timeOld;
};

}
#endif