InputParameters
validParams<EulerAngleProvider2RGBAux>()
{
InputParameters params = validParams<AuxKernel>();
params.addClassDescription("Output RGB representation of crystal orientation from user object to "
"an AuxVariable. The entire domain must have the same crystal "
"structure.");
MooseEnum sd_enum = MooseEnum("100=1 010=2 001=3", "001");
params.addParam<MooseEnum>("sd", sd_enum, "Reference sample direction");
MooseEnum structure_enum = MooseEnum(
"cubic=43 hexagonal=62 tetragonal=42 trigonal=32 orthorhombic=22 monoclinic=2 triclinic=1");
params.addRequiredParam<MooseEnum>(
"crystal_structure", structure_enum, "Crystal structure of the material");
MooseEnum output_types = MooseEnum("red green blue scalar", "scalar");
params.addParam<MooseEnum>("output_type", output_types, "Type of value that will be outputted");
params.addRequiredParam<UserObjectName>("euler_angle_provider",
"Name of Euler angle provider user object");
params.addRequiredParam<UserObjectName>("grain_tracker",
"The GrainTracker UserObject to get values from.");
params.addParam<Point>(
"no_grain_color",
Point(0, 0, 0),
"RGB value of color used to represent area with no grains, defaults to black");
return params;
}
MooseEnum
RankFourTensor::fillMethodEnum()
{
return MooseEnum("antisymmetric symmetric9 symmetric21 general_isotropic symmetric_isotropic "
"symmetric_isotropic_E_nu antisymmetric_isotropic axisymmetric_rz general "
"principal");
}
SolutionUserObject::SolutionUserObject(const std::string & name, InputParameters parameters) :
GeneralUserObject(name, parameters),
_file_type(MooseEnum("xda=0, exodusII=1")),
_mesh_file(getParam<std::string>("mesh")),
_es_file(getParam<std::string>("es")),
_system_name(getParam<std::string>("system")),
_nodal_vars(isParamValid("nodal_variables") ?
getParam<std::vector<std::string> >("nodal_variables") : std::vector<std::string>()),
_elem_vars(isParamValid("elemental_variables") ?
getParam<std::vector<std::string> >("elemental_variables") : std::vector<std::string>()),
_exodus_time_index(getParam<int>("timestep")),
_interpolate_times(false),
_mesh(NULL),
_es(NULL),
_system(NULL),
_mesh_function(NULL),
_exodusII_io(NULL),
_serialized_solution(NULL),
_es2(NULL),
_system2(NULL),
_mesh_function2(NULL),
_serialized_solution2(NULL),
_interpolation_time(0.0),
_interpolation_factor(0.0),
_exodus_times(NULL),
_exodus_index1(-1),
_exodus_index2(-1),
_scale(getParam<std::vector<Real> >("coord_scale")),
_factor(getParam<std::vector<Real> >("coord_factor"))
{
_exec_flags = EXEC_INITIAL;
}
InputParameters validParams<EBSDMesh>()
{
InputParameters params = validParams<GeneratedMesh>();
params.addClassDescription("Mesh generated from a specified EBSD data file");
params.addRequiredParam<FileName>("filename", "The name of the file containing the EBSD data");
params.addParam<unsigned int>("uniform_refine", 0, "Number of coarsening levels available in adaptive mesh refinement.");
// suppress parameters
params.suppressParameter<MooseEnum>("dim");
params.set<MooseEnum>("dim") = MooseEnum("1=1 2 3", "1");
params.suppressParameter<int>("nx");
params.suppressParameter<int>("ny");
params.suppressParameter<int>("nz");
params.suppressParameter<Real>("xmin");
params.suppressParameter<Real>("ymin");
params.suppressParameter<Real>("zmin");
params.suppressParameter<Real>("xmax");
params.suppressParameter<Real>("ymax");
params.suppressParameter<Real>("zmax");
return params;
}
MooseEnum
EBSDAccessFunctors::getAvgDataFieldType()
{
return MooseEnum("phi1 phi phi2 phase symmetry local grain", "", true);
}
MooseEnum
InteractionIntegral::qFunctionType()
{
return MooseEnum("Geometry Topology", "Geometry");
}
MooseEnum
GolemMaterialH::permeabilityType()
{
return MooseEnum("isotropic=1 orthotropic=2 anisotropic=3");
}
MooseEnum
EBSDAccessFunctors::getPointDataFieldType()
{
return MooseEnum("phi1 phi phi2 grain phase symmetry op", "", true);
}
MooseEnum
AddVariableAction::getNonlinearVariableFamilies()
{
return MooseEnum("LAGRANGE MONOMIAL HERMITE SCALAR HIERARCHIC CLOUGH XYZ SZABAB BERNSTEIN L2_LAGRANGE L2_HIERARCHIC", "LAGRANGE");
}
MooseEnum
AddAuxVariableAction::getAuxVariableFamilies()
{
return MooseEnum("LAGRANGE MONOMIAL SCALAR", "LAGRANGE", true);
}
MooseEnum
AddAuxVariableAction::getAuxVariableOrders()
{
return MooseEnum("CONSTANT, FIRST, SECOND", "FIRST", true);
}
SolutionUserObject::SolutionUserObject(const std::string & name, InputParameters parameters) :
GeneralUserObject(name, parameters),
_file_type(MooseEnum("xda=0, exodusII=1")),
_mesh_file(getParam<std::string>("mesh")),
_es_file(getParam<std::string>("es")),
_system_name(getParam<std::string>("system")),
_nodal_vars(isParamValid("nodal_variables") ?
getParam<std::vector<std::string> >("nodal_variables") : std::vector<std::string>()),
_elem_vars(isParamValid("elemental_variables") ?
getParam<std::vector<std::string> >("elemental_variables") : std::vector<std::string>()),
_exodus_time_index(getParam<int>("timestep")),
_interpolate_times(false),
_mesh(NULL),
_es(NULL),
_system(NULL),
_mesh_function(NULL),
_exodusII_io(NULL),
_serialized_solution(NULL),
_es2(NULL),
_system2(NULL),
_mesh_function2(NULL),
_serialized_solution2(NULL),
_interpolation_time(0.0),
_interpolation_factor(0.0),
_exodus_times(NULL),
_exodus_index1(-1),
_exodus_index2(-1),
_scale(getParam<std::vector<Real> >("scale")),
_scale_multiplier(getParam<std::vector<Real> >("scale_multiplier")),
_translation(getParam<std::vector<Real> >("translation")),
_rotation0_vector(getParam<RealVectorValue>("rotation0_vector")),
_rotation0_angle(getParam<Real>("rotation0_angle")),
_r0(RealTensorValue()),
_rotation1_vector(getParam<RealVectorValue>("rotation1_vector")),
_rotation1_angle(getParam<Real>("rotation1_angle")),
_r1(RealTensorValue()),
_transformation_order(getParam<std::vector<MooseEnum> >("transformation_order"))
{
_exec_flags = EXEC_INITIAL;
if (!parameters.isParamValid("nodal_variables") && !parameters.isParamValid("elemental_variables"))
mooseError("In SolutionUserObject " << _name << ", must supply nodal_variables or elemental_variables");
if (parameters.isParamValid("coord_scale"))
{
mooseWarning("Parameter name coord_scale is deprecated. Please use scale instead.");
_scale = getParam<std::vector<Real> >("coord_scale");
}
if (parameters.isParamValid("coord_factor"))
{
mooseWarning("Parameter name coord_factor is deprecated. Please use translation instead.");
_translation = getParam<std::vector<Real> >("coord_factor");
}
// form rotation matrices with the specified angles
Real halfPi = std::acos(0.0);
Real a;
Real b;
a = std::cos(halfPi*_rotation0_angle/90);
b = std::sin(halfPi*_rotation0_angle/90);
// the following is an anticlockwise rotation about z
RealTensorValue rot0_z(
a, -b, 0,
b, a, 0,
0, 0, 1);
// form the rotation matrix that will take rotation0_vector to the z axis
RealTensorValue vec0_to_z = RotationMatrix::rotVecToZ(_rotation0_vector);
// _r0 is then: rotate points so vec0 lies along z; then rotate about angle0; then rotate points back
_r0 = vec0_to_z.transpose()*(rot0_z*vec0_to_z);
a = std::cos(halfPi*_rotation1_angle/90);
b = std::sin(halfPi*_rotation1_angle/90);
// the following is an anticlockwise rotation about z
RealTensorValue rot1_z(
a, -b, 0,
b, a, 0,
0, 0, 1);
// form the rotation matrix that will take rotation1_vector to the z axis
RealTensorValue vec1_to_z = RotationMatrix::rotVecToZ(_rotation1_vector);
// _r1 is then: rotate points so vec1 lies along z; then rotate about angle1; then rotate points back
_r1 = vec1_to_z.transpose()*(rot1_z*vec1_to_z);
}
MooseEnum
InteractionIntegral::sifModeType()
{
return MooseEnum("KI KII KIII T", "KI");
}
MooseEnum
EBSDAccessFunctors::getPointDataFieldType()
{
return MooseEnum("phi1 phi phi2 feature_id phase symmetry", "", true);
}
MooseEnum
PolycrystalUserObjectBase::coloringAlgorithms()
{
return MooseEnum("jp power greedy bt", "jp");
}
MooseEnum RankThreeTensor::fillMethodEnum() // TODO: Need new fillMethodEnum() -- for now we will
// just use general (at most 27 components)
{
return MooseEnum("general");
}
MooseEnum
RankFourTensor::fillMethodEnum()
{
return MooseEnum("antisymmetric, symmetric9, symmetric21, general_isotropic, symmetric_isotropic, antisymmetric_isotropic, general");
}
MooseEnum
PolycrystalICTools::coloringAlgorithms()
{
return MooseEnum("legacy bt jp power greedy", "legacy");
}
MooseEnum
AddVariableAction::getNonlinearVariableFamilies()
{
return MooseEnum("LAGRANGE, MONOMIAL, HERMITE, SCALAR, HIERARCHIC, CLOUGH, XYZ, SZABAB, BERNSTEIN, L2_LAGRANGE, L2_HIERARCHIC", "LAGRANGE");
}
MooseEnum
GolemMaterialBase::materialType()
{
return MooseEnum("well=1 frac=2 unit=3");
}
void
FormattedTable::printTable(std::ostream & out, unsigned int last_n_entries)
{
printTable(out, last_n_entries, MooseEnum("ENVIRONMENT=-1", "ENVIRONMENT"));
}
MooseEnum
RankTwoTensor::fillMethodEnum()
{
return MooseEnum("autodetect=0 isotropic1=1 diagonal3=3 symmetric6=6 general=9", "autodetect");
}
MooseEnum
GolemStrain::strainType()
{
return MooseEnum("total=1 inelastic=2 plastic=3");
}
MooseEnum
AddVariableAction::getNonlinearVariableOrders()
{
return MooseEnum("CONSTANT FIRST SECOND THIRD FOURTH", "FIRST", true);
}
// DEPRECATED CONSTRUCTOR
SolutionUserObject::SolutionUserObject(const std::string & deprecated_name, InputParameters parameters) :
GeneralUserObject(deprecated_name, parameters),
_file_type(MooseEnum("xda=0 exodusII=1 xdr=2")),
_mesh_file(getParam<MeshFileName>("mesh")),
_es_file(getParam<FileName>("es")),
_system_name(getParam<std::string>("system")),
_system_variables(getParam<std::vector<std::string> >("system_variables")),
_exodus_time_index(getParam<int>("timestep")),
_interpolate_times(false),
_mesh(NULL),
_es(NULL),
_system(NULL),
_mesh_function(NULL),
_exodusII_io(NULL),
_serialized_solution(NULL),
_es2(NULL),
_system2(NULL),
_mesh_function2(NULL),
_serialized_solution2(NULL),
_interpolation_time(0.0),
_interpolation_factor(0.0),
_exodus_times(NULL),
_exodus_index1(-1),
_exodus_index2(-1),
_scale(getParam<std::vector<Real> >("scale")),
_scale_multiplier(getParam<std::vector<Real> >("scale_multiplier")),
_translation(getParam<std::vector<Real> >("translation")),
_rotation0_vector(getParam<RealVectorValue>("rotation0_vector")),
_rotation0_angle(getParam<Real>("rotation0_angle")),
_r0(RealTensorValue()),
_rotation1_vector(getParam<RealVectorValue>("rotation1_vector")),
_rotation1_angle(getParam<Real>("rotation1_angle")),
_r1(RealTensorValue()),
_transformation_order(getParam<MultiMooseEnum>("transformation_order")),
_initialized(false)
{
// form rotation matrices with the specified angles
Real halfPi = std::acos(0.0);
Real a;
Real b;
a = std::cos(halfPi*_rotation0_angle/90);
b = std::sin(halfPi*_rotation0_angle/90);
// the following is an anticlockwise rotation about z
RealTensorValue rot0_z(
a, -b, 0,
b, a, 0,
0, 0, 1);
// form the rotation matrix that will take rotation0_vector to the z axis
RealTensorValue vec0_to_z = RotationMatrix::rotVecToZ(_rotation0_vector);
// _r0 is then: rotate points so vec0 lies along z; then rotate about angle0; then rotate points back
_r0 = vec0_to_z.transpose()*(rot0_z*vec0_to_z);
a = std::cos(halfPi*_rotation1_angle/90);
b = std::sin(halfPi*_rotation1_angle/90);
// the following is an anticlockwise rotation about z
RealTensorValue rot1_z(
a, -b, 0,
b, a, 0,
0, 0, 1);
// form the rotation matrix that will take rotation1_vector to the z axis
RealTensorValue vec1_to_z = RotationMatrix::rotVecToZ(_rotation1_vector);
// _r1 is then: rotate points so vec1 lies along z; then rotate about angle1; then rotate points back
_r1 = vec1_to_z.transpose()*(rot1_z*vec1_to_z);
}
MooseEnum
AddAuxVariableAction::getAuxVariableOrders()
{
return MooseEnum("CONSTANT FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH NINTH", "FIRST", true);
}
MooseEnum
MooseEnum::withNamesFrom(const MooseEnumBase & other_enum)
{
return MooseEnum(other_enum);
}
