Ejemplo n.º 1
0
ElasticModulus<EvalT, Traits>::
ElasticModulus(Teuchos::ParameterList& p) :
    elasticModulus(p.get<std::string>("QP Variable Name"),
                   p.get<Teuchos::RCP<PHX::DataLayout>>("QP Scalar Data Layout"))
{
    Teuchos::ParameterList* elmd_list =
        p.get<Teuchos::ParameterList*>("Parameter List");

    Teuchos::RCP<PHX::DataLayout> vector_dl =
        p.get< Teuchos::RCP<PHX::DataLayout>>("QP Vector Data Layout");
    std::vector<PHX::DataLayout::size_type> dims;
    vector_dl->dimensions(dims);
    numQPs  = dims[1];
    numDims = dims[2];

    Teuchos::RCP<ParamLib> paramLib =
        p.get< Teuchos::RCP<ParamLib>>("Parameter Library", Teuchos::null);

    std::string type = elmd_list->get("Elastic Modulus Type", "Constant");
    if (type == "Constant") {
        is_constant = true;
        constant_value = elmd_list->get<double>("Value");

        // Add Elastic Modulus as a Sacado-ized parameter
        this->registerSacadoParameter("Elastic Modulus", paramLib);
    }
//  else if (type == 'Variable') {
//	  is_constant = true; // this means no stochastic nature
//	  is_field = true;
//	  constant_value = elmd_list->get("Value", 1.0);
//
//	  // Add Elastic Modulus as a Sacado-ized parameter
//	  new Sacado::ParameterRegistration<EvalT, SPL_Traits>(
//	  	"Elastic Modulus", this, paramLib);
//
//  }
    else if (type == "Truncated KL Expansion") {
        is_constant = false;
        PHX::MDField<MeshScalarT,Cell,QuadPoint,Dim>
        fx(p.get<std::string>("QP Coordinate Vector Name"), vector_dl);
        coordVec = fx;
        this->addDependentField(coordVec);

        exp_rf_kl =
            Teuchos::rcp(new Stokhos::KL::ExponentialRandomField<RealType>(*elmd_list));
        int num_KL = exp_rf_kl->stochasticDimension();

        // Add KL random variables as Sacado-ized parameters
        rv.resize(num_KL);
        for (int i=0; i<num_KL; i++) {
            std::string ss = Albany::strint("Elastic Modulus KL Random Variable",i);
            this->registerSacadoParameter(ss, paramLib);
            rv[i] = elmd_list->get(ss, 0.0);
        }
    }
    else {
        TEUCHOS_TEST_FOR_EXCEPTION(true, Teuchos::Exceptions::InvalidParameter,
                                   "Invalid elastic modulus type " << type);
    }

    // Optional dependence on Temperature (E = E_ + dEdT * T)
    // Switched ON by sending Temperature field in p

    if ( p.isType<std::string>("QP Temperature Name") ) {
        Teuchos::RCP<PHX::DataLayout> scalar_dl =
            p.get< Teuchos::RCP<PHX::DataLayout>>("QP Scalar Data Layout");
        PHX::MDField<ScalarT,Cell,QuadPoint>
        tmp(p.get<std::string>("QP Temperature Name"), scalar_dl);
        Temperature = tmp;
        this->addDependentField(Temperature);
        isThermoElastic = true;
        dEdT_value = elmd_list->get("dEdT Value", 0.0);
        refTemp = p.get<RealType>("Reference Temperature", 0.0);
        this->registerSacadoParameter("dEdT Value", paramLib);
    }
    else {
        isThermoElastic=false;
        dEdT_value=0.0;
    }

    // Optional dependence on porosity (E = E_ + dEdT * T)
    // Switched ON by sending Temperature field in p

    if ( p.isType<std::string>("Porosity Name") ) {
        Teuchos::RCP<PHX::DataLayout> scalar_dl =
            p.get< Teuchos::RCP<PHX::DataLayout>>("QP Scalar Data Layout");
        PHX::MDField<ScalarT,Cell,QuadPoint>
        tporo(p.get<std::string>("Porosity Name"), scalar_dl);
        porosity = tporo;
        this->addDependentField(porosity);
        isPoroElastic = true;

    }
    else {
        isPoroElastic= false;
    }


    this->addEvaluatedField(elasticModulus);
    this->setName("Elastic Modulus"+PHX::typeAsString<EvalT>());
}
EquivalentInclusionConductivity<EvalT, Traits>::
EquivalentInclusionConductivity(Teuchos::ParameterList& p) :
  effectiveK(p.get<std::string>("QP Variable Name"),
		 p.get<Teuchos::RCP<PHX::DataLayout>>("QP Scalar Data Layout"))
{
  Teuchos::ParameterList* elmd_list = 
    p.get<Teuchos::ParameterList*>("Parameter List");

  Teuchos::RCP<PHX::DataLayout> vector_dl =
    p.get< Teuchos::RCP<PHX::DataLayout>>("QP Vector Data Layout");
  std::vector<PHX::DataLayout::size_type> dims;
  vector_dl->dimensions(dims);
  numQPs  = dims[1];
  numDims = dims[2];

  Teuchos::RCP<ParamLib> paramLib = 
    p.get< Teuchos::RCP<ParamLib>>("Parameter Library", Teuchos::null);

  std::string type = elmd_list->get("Effective Thermal Conductivity Type", "Constant");
  if (type == "Constant") {
    is_constant = true;
    constant_value = elmd_list->get("Value", 1.0);

    // Add effective thermal conductivity as a Sacado-ized parameter
    this->registerSacadoParameter("Effective Thermal Conductivity", paramLib);
  }
#ifdef ALBANY_STOKHOS
  else if (type == "Truncated KL Expansion") {
    is_constant = false;
    PHX::MDField<MeshScalarT,Cell,QuadPoint,Dim>
      fx(p.get<std::string>("QP Coordinate Vector Name"), vector_dl);
    coordVec = fx;
    this->addDependentField(coordVec);

    exp_rf_kl = 
      Teuchos::rcp(new Stokhos::KL::ExponentialRandomField<RealType>(*elmd_list));
    int num_KL = exp_rf_kl->stochasticDimension();

    // Add KL random variables as Sacado-ized parameters
    rv.resize(num_KL);
    for (int i=0; i<num_KL; i++) {
      std::string ss = Albany::strint("Effective Thermal Conductivity KL Random Variable",i);
      this->registerSacadoParameter(ss, paramLib);
      rv[i] = elmd_list->get(ss, 1.0);
    }
  }
#endif
  else {
    TEUCHOS_TEST_FOR_EXCEPTION(true, Teuchos::Exceptions::InvalidParameter,
			       "Invalid effective thermal conductivity type " << type);
  } 


  if ( p.isType<std::string>("Porosity Name") ) {
      Teuchos::RCP<PHX::DataLayout> scalar_dl =
        p.get< Teuchos::RCP<PHX::DataLayout>>("QP Scalar Data Layout");
      PHX::MDField<ScalarT,Cell,QuadPoint>
        tporo(p.get<std::string>("Porosity Name"), scalar_dl);
      porosity = tporo;
      this->addDependentField(porosity);
      isPoroElastic = true;
    }
    else {
      isPoroElastic= false;
    }

  if ( p.isType<std::string>("Jacobian Name") ) {
      Teuchos::RCP<PHX::DataLayout> scalar_dl =
        p.get< Teuchos::RCP<PHX::DataLayout>>("QP Scalar Data Layout");
      PHX::MDField<ScalarT,Cell,QuadPoint>
        detf(p.get<std::string>("Jacobian Name"), scalar_dl);
      J = detf;
      this->addDependentField(J);
      isPoroElastic = true;
    }
  else {
    isPoroElastic= false;
  }

  condKs = elmd_list->get("Solid Thermal Conducutivity Value", 1.0);
  this->registerSacadoParameter("Solid Thermal Conductivity Value", paramLib);
  condKf = elmd_list->get("Fluid Thermal Conductivity Value", 100.0);
  this->registerSacadoParameter("Fluid Thermal Conductivity Value", paramLib);

  this->addEvaluatedField(effectiveK);
  this->setName("Effective Thermal Conductivity"+PHX::typeAsString<EvalT>());
}