void ElastoViscoplasticModel<EvalT, Traits>:: 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) { std::string cauchy_string = (*field_name_map_)["Cauchy_Stress"]; std::string Fp_string = (*field_name_map_)["Fp"]; std::string eqps_string = (*field_name_map_)["eqps"]; std::string eps_ss_string = (*field_name_map_)["eps_ss"]; std::string kappa_string = (*field_name_map_)["isotropic_hardening"]; std::string source_string = (*field_name_map_)["Mechanical_Source"]; std::string F_string = (*field_name_map_)["F"]; std::string J_string = (*field_name_map_)["J"]; // extract dependent MDFields PHX::MDField<ScalarT> def_grad_field = *dep_fields[F_string]; PHX::MDField<ScalarT> J = *dep_fields[J_string]; PHX::MDField<ScalarT> poissons_ratio = *dep_fields["Poissons Ratio"]; PHX::MDField<ScalarT> elastic_modulus = *dep_fields["Elastic Modulus"]; PHX::MDField<ScalarT> yield_strength = *dep_fields["Yield Strength"]; PHX::MDField<ScalarT> hardening_modulus = *dep_fields["Hardening Modulus"]; PHX::MDField<ScalarT> recovery_modulus = *dep_fields["Recovery Modulus"]; PHX::MDField<ScalarT> flow_exp = *dep_fields["Flow Rule Exponent"]; PHX::MDField<ScalarT> flow_coeff = *dep_fields["Flow Rule Coefficient"]; PHX::MDField<ScalarT> delta_time = *dep_fields["Delta Time"]; // extract evaluated MDFields PHX::MDField<ScalarT> stress_field = *eval_fields[cauchy_string]; PHX::MDField<ScalarT> Fp_field = *eval_fields[Fp_string]; PHX::MDField<ScalarT> eqps_field = *eval_fields[eqps_string]; PHX::MDField<ScalarT> eps_ss_field = *eval_fields[eps_ss_string]; PHX::MDField<ScalarT> kappa_field = *eval_fields[kappa_string]; PHX::MDField<ScalarT> source_field; if (have_temperature_) { source_field = *eval_fields[source_string]; } // get State Variables Albany::MDArray Fp_field_old = (*workset.stateArrayPtr)[Fp_string + "_old"]; Albany::MDArray eqps_field_old = (*workset.stateArrayPtr)[eqps_string + "_old"]; Albany::MDArray eps_ss_field_old = (*workset.stateArrayPtr)[eps_ss_string + "_old"]; Albany::MDArray kappa_field_old = (*workset.stateArrayPtr)[kappa_string + "_old"]; // define constants RealType sq23(std::sqrt(2. / 3.)); RealType sq32(std::sqrt(3. / 2.)); // pre-define some tensors that will be re-used below Intrepid::Tensor<ScalarT> F(num_dims_), be(num_dims_); Intrepid::Tensor<ScalarT> s(num_dims_), sigma(num_dims_); Intrepid::Tensor<ScalarT> N(num_dims_), A(num_dims_); Intrepid::Tensor<ScalarT> expA(num_dims_), Fpnew(num_dims_); Intrepid::Tensor<ScalarT> I(Intrepid::eye<ScalarT>(num_dims_)); Intrepid::Tensor<ScalarT> Fpn(num_dims_), Cpinv(num_dims_), Fpinv(num_dims_); for (std::size_t cell(0); cell < workset.numCells; ++cell) { for (std::size_t pt(0); pt < num_pts_; ++pt) { ScalarT bulk = elastic_modulus(cell, pt) / (3. * (1. - 2. * poissons_ratio(cell, pt))); ScalarT mu = elastic_modulus(cell, pt) / (2. * (1. + poissons_ratio(cell, pt))); ScalarT Y = yield_strength(cell, pt); ScalarT Jm23 = std::pow(J(cell, pt), -2. / 3.); // assign local state variables // //ScalarT kappa = kappa_field(cell,pt); ScalarT kappa_old = kappa_field_old(cell,pt); ScalarT eps_ss = eps_ss_field(cell,pt); ScalarT eps_ss_old = eps_ss_field_old(cell,pt); ScalarT eqps_old = eqps_field_old(cell,pt); // fill local tensors // F.fill(&def_grad_field(cell, pt, 0, 0)); for (std::size_t i(0); i < num_dims_; ++i) { for (std::size_t j(0); j < num_dims_; ++j) { Fpn(i, j) = ScalarT(Fp_field_old(cell, pt, i, j)); } } // compute trial state // compute the Kirchhoff stress in the current configuration // Cpinv = Intrepid::inverse(Fpn) * Intrepid::transpose(Intrepid::inverse(Fpn)); be = Jm23 * F * Cpinv * Intrepid::transpose(F); s = mu * Intrepid::dev(be); ScalarT smag = Intrepid::norm(s); ScalarT mubar = Intrepid::trace(be) * mu / (num_dims_); // check yield condition // ScalarT Phi = sq32 * smag - ( Y + kappa_old ); std::cout << "======== Phi: " << Phi << std::endl; std::cout << "======== eps: " << std::numeric_limits<RealType>::epsilon() << std::endl; if (Phi > std::numeric_limits<RealType>::epsilon()) { // return mapping algorithm // bool converged = false; int iter = 0; RealType max_norm = std::numeric_limits<RealType>::min(); // hardening and recovery parameters // ScalarT H = hardening_modulus(cell, pt); ScalarT Rd = recovery_modulus(cell, pt); // flow rule temperature dependent parameters // ScalarT f = flow_coeff(cell,pt); ScalarT n = flow_exp(cell,pt); // This solver deals with Sacado type info // LocalNonlinearSolver<EvalT, Traits> solver; // create some vectors to store solver data // std::vector<ScalarT> R(2); std::vector<ScalarT> dRdX(4); std::vector<ScalarT> X(2); // initial guess X[0] = 0.0; X[1] = eps_ss_old; // create a copy of be as a Fad Intrepid::Tensor<Fad> beF(num_dims_); for (std::size_t i = 0; i < num_dims_; ++i) { for (std::size_t j = 0; j < num_dims_; ++j) { beF(i, j) = be(i, j); } } Fad two_mubarF = 2.0 * Intrepid::trace(beF) * mu / (num_dims_); //Fad sq32F = std::sqrt(3.0/2.0); // FIXME this seems to be necessary to get PhiF to compile below // need to look into this more, it appears to be a conflict // between the Intrepid::norm and FadType operations // Fad smagF = smag; while (!converged) { // set up data types // std::vector<Fad> XFad(2); std::vector<Fad> RFad(2); std::vector<ScalarT> Xval(2); for (std::size_t i = 0; i < 2; ++i) { Xval[i] = Sacado::ScalarValue<ScalarT>::eval(X[i]); XFad[i] = Fad(2, i, Xval[i]); } // get solution vars // Fad dgamF = XFad[0]; Fad eps_ssF = XFad[1]; // compute yield function // Fad eqps_rateF = 0.0; if (delta_time(0) > 0) eqps_rateF = sq23 * dgamF / delta_time(0); Fad rate_termF = 1.0 + std::asinh( std::pow(eqps_rateF / f, n)); Fad kappaF = two_mubarF * eps_ssF; Fad PhiF = sq32 * (smagF - two_mubarF * dgamF) - ( Y + kappaF ) * rate_termF; // compute the hardening residual // Fad eps_resF = eps_ssF - eps_ss_old - (H - Rd*eps_ssF) * dgamF; // for convenience put the residuals into a container // RFad[0] = PhiF; RFad[1] = eps_resF; // extract the values of the residuals // for (int i = 0; i < 2; ++i) R[i] = RFad[i].val(); // extract the sensitivities of the residuals // for (int i = 0; i < 2; ++i) for (int j = 0; j < 2; ++j) dRdX[i + 2 * j] = RFad[i].dx(j); // this call invokes the solver and updates the solution in X // solver.solve(dRdX, X, R); // compute the norm of the residual // RealType R0 = Sacado::ScalarValue<ScalarT>::eval(R[0]); RealType R1 = Sacado::ScalarValue<ScalarT>::eval(R[1]); RealType norm_res = std::sqrt(R0*R0 + R1*R1); max_norm = std::max(norm_res, max_norm); // check against too many inerations // TEUCHOS_TEST_FOR_EXCEPTION(iter == 30, std::runtime_error, std::endl << "Error in ElastoViscoplastic return mapping\n" << "iter count = " << iter << "\n" << std::endl); // check for a sufficiently small residual // std::cout << "======== norm_res : " << norm_res << std::endl; if ( (norm_res/max_norm < 1.e-12) || (norm_res < 1.e-12) ) converged = true; // increment the iteratio counter // iter++; } solver.computeFadInfo(dRdX, X, R); ScalarT dgam = X[0]; ScalarT eps_ss = X[1]; ScalarT kappa = 2.0 * mubar * eps_ss; std::cout << "======== dgam : " << dgam << std::endl; std::cout << "======== e_ss : " << eps_ss << std::endl; std::cout << "======== kapp : " << kappa << std::endl; // plastic direction N = (1 / smag) * s; // update s s -= 2 * mubar * dgam * N; // update state variables eps_ss_field(cell, pt) = eps_ss; eqps_field(cell,pt) = eqps_old + sq23 * dgam; kappa_field(cell,pt) = kappa; // mechanical source // FIXME this is not correct, just a placeholder // if (have_temperature_ && delta_time(0) > 0) { source_field(cell, pt) = (sq23 * dgam / delta_time(0)) * (Y + kappa) / (density_ * heat_capacity_); } // exponential map to get Fpnew // A = dgam * N; expA = Intrepid::exp(A); Fpnew = expA * Fpn; for (std::size_t i(0); i < num_dims_; ++i) { for (std::size_t j(0); j < num_dims_; ++j) { Fp_field(cell, pt, i, j) = Fpnew(i, j); } } } else { // we are not yielding, variables do not evolve // eps_ss_field(cell, pt) = eps_ss_old; eqps_field(cell,pt) = eqps_old; kappa_field(cell,pt) = kappa_old; if (have_temperature_) source_field(cell, pt) = 0.0; for (std::size_t i(0); i < num_dims_; ++i) { for (std::size_t j(0); j < num_dims_; ++j) { Fp_field(cell, pt, i, j) = Fpn(i, j); } } } // compute pressure ScalarT p = 0.5 * bulk * (J(cell, pt) - 1. / (J(cell, pt))); // compute stress sigma = p * I + s / J(cell, pt); for (std::size_t i(0); i < num_dims_; ++i) { for (std::size_t j(0); j < num_dims_; ++j) { stress_field(cell, pt, i, j) = sigma(i, j); } } } } if (have_temperature_) { for (std::size_t cell(0); cell < workset.numCells; ++cell) { for (std::size_t pt(0); pt < num_pts_; ++pt) { F.fill(&def_grad_field(cell,pt,0,0)); ScalarT J = Intrepid::det(F); sigma.fill(&stress_field(cell,pt,0,0)); sigma -= 3.0 * expansion_coeff_ * (1.0 + 1.0 / (J*J)) * (temperature_(cell,pt) - ref_temperature_) * I; for (std::size_t i = 0; i < num_dims_; ++i) { for (std::size_t j = 0; j < num_dims_; ++j) { stress_field(cell, pt, i, j) = sigma(i, j); } } } } } }
ShearModulus<EvalT, Traits>:: ShearModulus(Teuchos::ParameterList& p) : shearModulus(p.get<std::string>("QP Variable Name"), p.get<Teuchos::RCP<PHX::DataLayout> >("QP Scalar Data Layout")) { Teuchos::ParameterList* shmd_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 = shmd_list->get("Shear Modulus Type", "Constant"); if (type == "Constant") { is_constant = true; constant_value = shmd_list->get("Value", 1.0); // Add Shear Modulus as a Sacado-ized parameter new Sacado::ParameterRegistration<EvalT, SPL_Traits>( "Shear 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<MeshScalarT>(*shmd_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("Shear Modulus KL Random Variable",i); new Sacado::ParameterRegistration<EvalT, SPL_Traits>(ss, this, paramLib); rv[i] = shmd_list->get(ss, 0.0); } } else { TEUCHOS_TEST_FOR_EXCEPTION(true, Teuchos::Exceptions::InvalidParameter, "Invalid shear modulus type " << type); } 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; dmudT_value = shmd_list->get("dmudT Value", 0.0); refTemp = p.get<RealType>("Reference Temperature", 0.0); new Sacado::ParameterRegistration<EvalT, SPL_Traits>( "dmudT Value", this, paramLib); } else { isThermoElastic=false; dmudT_value=0.0; } this->addEvaluatedField(shearModulus); this->setName("Shear Modulus"+PHX::TypeString<EvalT>::value); }
void Basis_HVOL_TRI_C0_FEM<Scalar, ArrayScalar>::getValues(ArrayScalar & outputValues, const ArrayScalar & inputPoints, const EOperator operatorType) const { // Verify arguments #ifdef HAVE_INTREPID_DEBUG Intrepid::getValues_HGRAD_Args<Scalar, ArrayScalar>(outputValues, inputPoints, operatorType, this -> getBaseCellTopology(), this -> getCardinality() ); #endif // Number of evaluation points = dim 0 of inputPoints int dim0 = inputPoints.dimension(0); // Temporaries: (x,y) coordinates of the evaluation point Scalar x = 0.0; Scalar y = 0.0; switch (operatorType) { case OPERATOR_VALUE: for (int i0 = 0; i0 < dim0; i0++) { x = inputPoints(i0, 0); y = inputPoints(i0, 1); // outputValues is a rank-2 array with dimensions (basisCardinality_, dim0) outputValues(0, i0) = 1.0; } break; case OPERATOR_GRAD: case OPERATOR_D1: for (int i0 = 0; i0 < dim0; i0++) { x = inputPoints(i0,0); y = inputPoints(i0,1); // outputValues is a rank-3 array with dimensions (basisCardinality_, dim0, spaceDim) outputValues(0, i0, 0) = 0.0; outputValues(0, i0, 1) = 0.0; } break; case OPERATOR_CURL: for (int i0 = 0; i0 < dim0; i0++) { x = inputPoints(i0,0); y = inputPoints(i0,1); // outputValues is a rank-3 array with dimensions (basisCardinality_, dim0, spaceDim) outputValues(0, i0, 0) = 0.0; outputValues(0, i0, 1) = 0.0; } break; case OPERATOR_DIV: TEUCHOS_TEST_FOR_EXCEPTION( (operatorType == OPERATOR_DIV), std::invalid_argument, ">>> ERROR (Basis_HGRAD_QUAD_Cr_FEM): DIV is invalid operator for rank-0 (scalar) functions in 2D"); break; case OPERATOR_D2: case OPERATOR_D3: case OPERATOR_D4: case OPERATOR_D5: case OPERATOR_D6: case OPERATOR_D7: case OPERATOR_D8: case OPERATOR_D9: case OPERATOR_D10: { // outputValues is a rank-3 array with dimensions (basisCardinality_, dim0, DkCardinality) int DkCardinality = Intrepid::getDkCardinality(operatorType, this -> basisCellTopology_.getDimension() ); for(int dofOrd = 0; dofOrd < this -> basisCardinality_; dofOrd++) { for (int i0 = 0; i0 < dim0; i0++) { for(int dkOrd = 0; dkOrd < DkCardinality; dkOrd++){ outputValues(dofOrd, i0, dkOrd) = 0.0; } } } } break; default: TEUCHOS_TEST_FOR_EXCEPTION( !( Intrepid::isValidOperator(operatorType) ), std::invalid_argument, ">>> ERROR (Basis_HVOL_TRI_C0_FEM): Invalid operator type"); } }
/*! \brief Signal that data entry is complete, specifying domain and range maps. Off-node indices are distributed (via globalAssemble()), indices are sorted, redundant indices are eliminated, and global indices are transformed to local indices. \pre <tt>isFillActive() == true<tt> \pre <tt>isFillComplete()() == false<tt> \post <tt>isFillActive() == false<tt> \post <tt>isFillComplete() == true<tt> \post if <tt>os == DoOptimizeStorage<tt>, then <tt>isStorageOptimized() == true</tt> */ void fillComplete(const RCP<const Map> &domainMap, const RCP<const Map> &rangeMap, const RCP<ParameterList> ¶ms=null) { TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::RuntimeError, "fillComplete with arguments not supported for block matrices" ); }
void panzer::AssemblyEngine<EvalT>:: evaluateBCs(const panzer::BCType bc_type, const panzer::AssemblyEngineInArgs& in, const Teuchos::RCP<LinearObjContainer> preEval_loc) { Teuchos::RCP<panzer::WorksetContainer> wkstContainer = m_field_manager_builder->getWorksetContainer(); panzer::Traits::PreEvalData ped; ped.gedc.addDataObject("Dirichlet Counter",preEval_loc); ped.gedc.addDataObject("Solution Gather Container",in.ghostedContainer_); ped.gedc.addDataObject("Residual Scatter Container",in.ghostedContainer_); ped.first_sensitivities_name = in.first_sensitivities_name; ped.second_sensitivities_name = in.second_sensitivities_name; in.fillGlobalEvaluationDataContainer(ped.gedc); // this helps work around issues when constructing a mass // matrix using an evaluation of only the transient terms. // In particular, the terms associated with the dirichlet // conditions. double betaValue = in.beta; // default to the passed in beta if(bc_type==panzer::BCT_Dirichlet && in.apply_dirichlet_beta) { betaValue = in.dirichlet_beta; } { const std::map<panzer::BC, std::map<unsigned,PHX::FieldManager<panzer::Traits> >, panzer::LessBC>& bc_field_managers = m_field_manager_builder->getBCFieldManagers(); // Must do all neumann before all dirichlet so we need a double loop // here over all bcs typedef typename std::map<panzer::BC, std::map<unsigned,PHX::FieldManager<panzer::Traits> >, panzer::LessBC>::const_iterator bcfm_it_type; // loop over bcs for (bcfm_it_type bcfm_it = bc_field_managers.begin(); bcfm_it != bc_field_managers.end(); ++bcfm_it) { const panzer::BC& bc = bcfm_it->first; const std::map<unsigned,PHX::FieldManager<panzer::Traits> > bc_fm = bcfm_it->second; Teuchos::RCP<const std::map<unsigned,panzer::Workset> > bc_wkst_ptr = wkstContainer->getSideWorksets(bc); TEUCHOS_TEST_FOR_EXCEPTION(bc_wkst_ptr == Teuchos::null, std::logic_error, "Failed to find corresponding bc workset!"); const std::map<unsigned,panzer::Workset>& bc_wkst = *bc_wkst_ptr; // Only process bcs of the appropriate type (neumann or dirichlet) if (bc.bcType() == bc_type) { // Loop over local faces for (std::map<unsigned,PHX::FieldManager<panzer::Traits> >::const_iterator side = bc_fm.begin(); side != bc_fm.end(); ++side) { // extract field manager for this side unsigned local_side_index = side->first; PHX::FieldManager<panzer::Traits>& local_side_fm = const_cast<PHX::FieldManager<panzer::Traits>& >(side->second); // extract workset for this side: only one workset per face std::map<unsigned,panzer::Workset>::const_iterator wkst_it = bc_wkst.find(local_side_index); TEUCHOS_TEST_FOR_EXCEPTION(wkst_it == bc_wkst.end(), std::logic_error, "Failed to find corresponding bc workset side!"); panzer::Workset& workset = const_cast<panzer::Workset&>(wkst_it->second); // run prevaluate local_side_fm.template preEvaluate<EvalT>(ped); // build and evaluate fields for the workset: only one workset per face workset.alpha = in.alpha; workset.beta = betaValue; workset.time = in.time; workset.gather_seeds = in.gather_seeds; workset.evaluate_transient_terms = in.evaluate_transient_terms; local_side_fm.template evaluateFields<EvalT>(workset); // run postevaluate for consistency local_side_fm.template postEvaluate<EvalT>(NULL); } } } } }
//! Scale the current values of a matrix, this = alpha*this. void scale(const Scalar &alpha) { TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::RuntimeError, "scale not supported by BlockedCrsMatrix" ); }
/*! Resume fill operations. After calling fillComplete(), resumeFill() must be called before initiating any changes to the matrix. resumeFill() may be called repeatedly. \post <tt>isFillActive() == true<tt> \post <tt>isFillComplete() == false<tt> */ void resumeFill(const RCP< ParameterList > ¶ms=null) { TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::RuntimeError, "resumeFill not supported for block matrices" ); }
void removeEmptyProcessesInPlace(const Teuchos::RCP<const Map>& newMap) { TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::RuntimeError, "removeEmptyProcesses not supported by BlockedCrsMatrix"); }
/** All index values must be in the local space. Note that if a value is not already present for the specified location in the matrix, the input value will be ignored silently. */ void replaceLocalValues(LocalOrdinal localRow, const ArrayView<const LocalOrdinal> &cols, const ArrayView<const Scalar> &vals) { TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::RuntimeError, "replaceLocalValues not supported by BlockedCrsMatrix" ); }
//! Constructor specifying column Map and fixed number of entries for each row. EpetraCrsGraphT(const RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > &rowMap, const RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > &colMap, size_t maxNumEntriesPerRow, ProfileType pftype=DynamicProfile, const Teuchos::RCP< Teuchos::ParameterList > &plist=null) { TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::RuntimeError, "Xpetra::EpetraCrsGraph only available for GO=int or GO=long long with EpetraNode (Serial or OpenMP depending on configuration)"); }
Teuchos::RCP<Epetra_MultiVector> MatrixMarketFileIOHandler::Read( const std::vector<std::string>& filenames ) { Teuchos::RCP<Epetra_MultiVector> newMV; if (isInit) { #ifdef EPETRA_MPI Epetra_MpiComm comm( MPI_COMM_WORLD ); #else Epetra_SerialComm comm; #endif int i, rows = 0; int num_vecs = 0; int num_files = filenames.size(); std::vector<int> cols(num_files,0); FILE * handle = 0; for (i=0; i<num_files; ++i) { int info = 0, rows_i = 0; // Open the data file std::string temp_filename = in_path + filenames[i]; handle = fopen(temp_filename.c_str(), "r"); TEUCHOS_TEST_FOR_EXCEPTION(handle==0, std::invalid_argument, "File named '"+temp_filename+"' does not exist or is not readable!"); // Get the array dimensions info = EpetraExt::mm_read_mtx_array_size( handle, &rows_i, &cols[i] ); TEUCHOS_TEST_FOR_EXCEPTION(info!=0, std::runtime_error, "Error reading file with name '"+temp_filename+"'!"); if (i==0) { rows = rows_i; // Get the number of rows from the first file } else { // Check to make sure the number of rows is the same. TEUCHOS_TEST_FOR_EXCEPTION(rows_i!=rows, std::logic_error, "Error reading file '"+temp_filename+"', does not have same number of rows!"); } // Add the number of columns up. num_vecs += cols[i]; // Close the data file fclose( handle ); } // Create the map and full multivector. Epetra_Map Map( rows, 0, comm ); newMV = Teuchos::rcp( new Epetra_MultiVector( Map, num_vecs ) ); // Create a pointer to a multivector int col_ptr = 0; Epetra_MultiVector* fileMV = 0; for ( i=0; i<num_files; i++ ) { // // Read in Epetra_MultiVector from file. // std::string curr_filename = in_path + filenames[i]; int info = EpetraExt::MatrixMarketFileToMultiVector( curr_filename.c_str(), Map, fileMV ); TEUCHOS_TEST_FOR_EXCEPTION(info!=0, std::runtime_error, "Error reading file with name '"+curr_filename+"'!"); // // Get a view of the multivector columns. // Epetra_MultiVector subMV( View, *newMV, col_ptr, cols[i] ); // // Put the multivector read in from the file into this subview. // subMV.Update( 1.0, *fileMV, 0.0 ); // // Update the column pointer // col_ptr += cols[i]; // // Clean up the multivector // if (fileMV) { delete fileMV; fileMV=0; } } } else { TEUCHOS_TEST_FOR_EXCEPTION(true, std::runtime_error, "File I/O handler is not initialized!"); } // Return. return newMV; }
//! EpetraCrsGraphT constructor to wrap a Epetra_CrsGraph object EpetraCrsGraphT(const Teuchos::RCP<Epetra_CrsGraph> &graph) : graph_(graph) { TEUCHOS_TEST_FOR_EXCEPTION(!graph->RowMap().GlobalIndicesIsType<GlobalOrdinal>(), std::runtime_error, "Xpetra::EpetraCrsGraphT: GlobalOrdinal mismatch."); }
//! EpetraCrsGraphT constructor to wrap a Epetra_CrsGraph object EpetraCrsGraphT(const Teuchos::RCP<Epetra_CrsGraph> &graph) { TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::RuntimeError, "Xpetra::EpetraCrsGraph only available for GO=int or GO=long long with EpetraNode (Serial or OpenMP depending on configuration)"); }
Real integrateCDF(const Real input) const { TEUCHOS_TEST_FOR_EXCEPTION( true, std::invalid_argument, ">>> ERROR (ROL::Gaussian): Gaussian integrateCDF not implemented!"); return ((input < mean_) ? 0.0 : input); }
void RebalanceBlockRestrictionFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node, LocalMatOps>::Build(Level &fineLevel, Level &coarseLevel) const { FactoryMonitor m(*this, "Build", coarseLevel); //const Teuchos::ParameterList & pL = GetParameterList(); RCP<Teuchos::FancyOStream> out = Teuchos::fancyOStream(Teuchos::rcpFromRef(std::cout)); Teuchos::RCP<Matrix> originalTransferOp = Teuchos::null; originalTransferOp = Get< RCP<Matrix> >(coarseLevel, "R"); RCP<Xpetra::BlockedCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node, LocalMatOps> > bOriginalTransferOp = Teuchos::rcp_dynamic_cast<Xpetra::BlockedCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node, LocalMatOps> >(originalTransferOp); TEUCHOS_TEST_FOR_EXCEPTION(bOriginalTransferOp==Teuchos::null, Exceptions::BadCast, "MueLu::RebalanceBlockTransferFactory::Build: input matrix P or R is not of type BlockedCrsMatrix! error."); // plausibility check TEUCHOS_TEST_FOR_EXCEPTION(bOriginalTransferOp->Rows() != 2,Exceptions::RuntimeError, "MueLu::RebalanceBlockTransferFactory::Build: number of block rows of transfer operator is not equal 2. error."); TEUCHOS_TEST_FOR_EXCEPTION(bOriginalTransferOp->Cols() != 2,Exceptions::RuntimeError, "MueLu::RebalanceBlockTransferFactory::Build: number of block columns of transfer operator is not equal 2. error."); // rebuild rebalanced blocked P operator std::vector<GO> fullRangeMapVector; std::vector<GO> fullDomainMapVector; std::vector<RCP<const Map> > subBlockRRangeMaps; std::vector<RCP<const Map> > subBlockRDomainMaps; subBlockRRangeMaps.reserve(bOriginalTransferOp->Rows()); // reserve size for block P operators subBlockRDomainMaps.reserve(bOriginalTransferOp->Cols()); // reserve size for block P operators std::vector<Teuchos::RCP<Matrix> > subBlockRebR; subBlockRebR.reserve(bOriginalTransferOp->Cols()); int curBlockId = 0; Teuchos::RCP<const Import> rebalanceImporter = Teuchos::null; std::vector<Teuchos::RCP<const FactoryManagerBase> >::const_iterator it; for (it = FactManager_.begin(); it != FactManager_.end(); ++it) { // begin SubFactoryManager environment SetFactoryManager fineSFM (rcpFromRef(fineLevel), *it); SetFactoryManager coarseSFM(rcpFromRef(coarseLevel), *it); rebalanceImporter = coarseLevel.Get<Teuchos::RCP<const Import> >("Importer", (*it)->GetFactory("Importer").get()); // extract matrix block Teuchos::RCP<CrsMatrix> Rmii = bOriginalTransferOp->getMatrix(curBlockId, curBlockId); Teuchos::RCP<CrsMatrixWrap> Rwii = Teuchos::rcp(new CrsMatrixWrap(Rmii)); Teuchos::RCP<Matrix> Rii = Teuchos::rcp_dynamic_cast<Matrix>(Rwii); Teuchos::RCP<Matrix> rebRii; if(rebalanceImporter != Teuchos::null) { std::stringstream ss; ss << "Rebalancing restriction block R(" << curBlockId << "," << curBlockId << ")"; SubFactoryMonitor m1(*this, ss.str(), coarseLevel); { SubFactoryMonitor subM(*this, "Rebalancing restriction -- fusedImport", coarseLevel); // Note: The 3rd argument says to use originalR's domain map. RCP<Map> dummy; rebRii = MatrixFactory::Build(Rii,*rebalanceImporter,dummy,rebalanceImporter->getTargetMap()); } RCP<ParameterList> params = rcp(new ParameterList()); params->set("printLoadBalancingInfo", true); std::stringstream ss2; ss2 << "R(" << curBlockId << "," << curBlockId << ") rebalanced:"; GetOStream(Statistics0) << PerfUtils::PrintMatrixInfo(*rebRii, ss2.str(), params); } else { rebRii = Rii; RCP<ParameterList> params = rcp(new ParameterList()); params->set("printLoadBalancingInfo", true); std::stringstream ss2; ss2 << "R(" << curBlockId << "," << curBlockId << ") not rebalanced:"; GetOStream(Statistics0) << PerfUtils::PrintMatrixInfo(*rebRii, ss2.str(), params); } // fix striding information for rebalanced diagonal block rebRii RCP<const Xpetra::MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node> > rgRMapExtractor = bOriginalTransferOp->getRangeMapExtractor(); // original map extractor Teuchos::RCP<const StridedMap> orig_stridedRgMap = Teuchos::rcp_dynamic_cast<const StridedMap>(rgRMapExtractor->getMap(Teuchos::as<size_t>(curBlockId))); Teuchos::RCP<const Map> stridedRgMap = Teuchos::null; if(orig_stridedRgMap != Teuchos::null) { std::vector<size_t> stridingData = orig_stridedRgMap->getStridingData(); Teuchos::ArrayView< const GlobalOrdinal > nodeRangeMapii = rebRii->getRangeMap()->getNodeElementList(); stridedRgMap = StridedMapFactory::Build( originalTransferOp->getRangeMap()->lib(), Teuchos::OrdinalTraits<Xpetra::global_size_t>::invalid(), nodeRangeMapii, rebRii->getRangeMap()->getIndexBase(), stridingData, originalTransferOp->getRangeMap()->getComm(), orig_stridedRgMap->getStridedBlockId(), orig_stridedRgMap->getOffset()); } RCP<const Xpetra::MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node> > doRMapExtractor = bOriginalTransferOp->getDomainMapExtractor(); // original map extractor Teuchos::RCP<const StridedMap> orig_stridedDoMap = Teuchos::rcp_dynamic_cast<const StridedMap>(doRMapExtractor->getMap(Teuchos::as<size_t>(curBlockId))); Teuchos::RCP<const Map> stridedDoMap = Teuchos::null; if(orig_stridedDoMap != Teuchos::null) { std::vector<size_t> stridingData = orig_stridedDoMap->getStridingData(); Teuchos::ArrayView< const GlobalOrdinal > nodeDomainMapii = rebRii->getDomainMap()->getNodeElementList(); stridedDoMap = StridedMapFactory::Build( originalTransferOp->getDomainMap()->lib(), Teuchos::OrdinalTraits<Xpetra::global_size_t>::invalid(), nodeDomainMapii, rebRii->getDomainMap()->getIndexBase(), stridingData, originalTransferOp->getDomainMap()->getComm(), orig_stridedDoMap->getStridedBlockId(), orig_stridedDoMap->getOffset()); } TEUCHOS_TEST_FOR_EXCEPTION(stridedRgMap == Teuchos::null,Exceptions::RuntimeError, "MueLu::RebalanceBlockRestrictionFactory::Build: failed to generate striding information. error."); TEUCHOS_TEST_FOR_EXCEPTION(stridedDoMap == Teuchos::null,Exceptions::RuntimeError, "MueLu::RebalanceBlockRestrictionFactory::Build: failed to generate striding information. error."); // replace stridedMaps view in diagonal sub block if(rebRii->IsView("stridedMaps")) rebRii->RemoveView("stridedMaps"); rebRii->CreateView("stridedMaps", stridedRgMap, stridedDoMap); // store rebalanced subblock subBlockRebR.push_back(rebRii); // append strided row map (= range map) to list of range maps. Teuchos::RCP<const Map> rangeMapii = rebRii->getRowMap("stridedMaps"); //rebRii->getRangeMap(); subBlockRRangeMaps.push_back(rangeMapii); Teuchos::ArrayView< const GlobalOrdinal > nodeRangeMapii = rebRii->getRangeMap()->getNodeElementList(); fullRangeMapVector.insert(fullRangeMapVector.end(), nodeRangeMapii.begin(), nodeRangeMapii.end()); sort(fullRangeMapVector.begin(), fullRangeMapVector.end()); // append strided col map (= domain map) to list of range maps. Teuchos::RCP<const Map> domainMapii = rebRii->getColMap("stridedMaps"); //rebRii->getDomainMap(); subBlockRDomainMaps.push_back(domainMapii); Teuchos::ArrayView< const GlobalOrdinal > nodeDomainMapii = rebRii->getDomainMap()->getNodeElementList(); fullDomainMapVector.insert(fullDomainMapVector.end(), nodeDomainMapii.begin(), nodeDomainMapii.end()); sort(fullDomainMapVector.begin(), fullDomainMapVector.end()); //////////////////////////////////////////////////////////// // rebalance null space if(rebalanceImporter != Teuchos::null) { // rebalance null space std::stringstream ss2; ss2 << "Rebalancing nullspace block(" << curBlockId << "," << curBlockId << ")"; SubFactoryMonitor subM(*this, ss2.str(), coarseLevel); RCP<MultiVector> nullspace = coarseLevel.Get<RCP<MultiVector> >("Nullspace", (*it)->GetFactory("Nullspace").get()); RCP<MultiVector> permutedNullspace = MultiVectorFactory::Build(rebalanceImporter->getTargetMap(), nullspace->getNumVectors()); permutedNullspace->doImport(*nullspace, *rebalanceImporter, Xpetra::INSERT); // TODO think about this //if (pL.get<bool>("useSubcomm") == true) // TODO either useSubcomm is enabled everywhere or nowhere //permutedNullspace->replaceMap(permutedNullspace->getMap()->removeEmptyProcesses()); coarseLevel.Set<RCP<MultiVector> >("Nullspace", permutedNullspace, (*it)->GetFactory("Nullspace").get()); } // end rebalance null space else { // do nothing RCP<MultiVector> nullspace = coarseLevel.Get<RCP<MultiVector> >("Nullspace", (*it)->GetFactory("Nullspace").get()); coarseLevel.Set<RCP<MultiVector> >("Nullspace", nullspace, (*it)->GetFactory("Nullspace").get()); } //////////////////////////////////////////////////////////// curBlockId++; } // end for loop // extract map index base from maps of blocked P GO rangeIndexBase = originalTransferOp->getRangeMap()->getIndexBase(); GO domainIndexBase= originalTransferOp->getDomainMap()->getIndexBase(); // check this RCP<const Xpetra::MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node> > rangeRMapExtractor = bOriginalTransferOp->getRangeMapExtractor(); // original map extractor Teuchos::ArrayView<GO> fullRangeMapGIDs(&fullRangeMapVector[0],fullRangeMapVector.size()); Teuchos::RCP<const StridedMap> stridedRgFullMap = Teuchos::rcp_dynamic_cast<const StridedMap>(rangeRMapExtractor->getFullMap()); Teuchos::RCP<const Map > fullRangeMap = Teuchos::null; if(stridedRgFullMap != Teuchos::null) { std::vector<size_t> stridedData = stridedRgFullMap->getStridingData(); fullRangeMap = StridedMapFactory::Build( originalTransferOp->getRangeMap()->lib(), Teuchos::OrdinalTraits<Xpetra::global_size_t>::invalid(), fullRangeMapGIDs, rangeIndexBase, stridedData, originalTransferOp->getRangeMap()->getComm(), stridedRgFullMap->getStridedBlockId(), stridedRgFullMap->getOffset()); } else { fullRangeMap = MapFactory::Build( originalTransferOp->getRangeMap()->lib(), Teuchos::OrdinalTraits<Xpetra::global_size_t>::invalid(), fullRangeMapGIDs, rangeIndexBase, originalTransferOp->getRangeMap()->getComm()); } RCP<const Xpetra::MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node> > domainAMapExtractor = bOriginalTransferOp->getDomainMapExtractor(); Teuchos::ArrayView<GO> fullDomainMapGIDs(&fullDomainMapVector[0],fullDomainMapVector.size()); Teuchos::RCP<const StridedMap> stridedDoFullMap = Teuchos::rcp_dynamic_cast<const StridedMap>(domainAMapExtractor->getFullMap()); Teuchos::RCP<const Map > fullDomainMap = Teuchos::null; if(stridedDoFullMap != Teuchos::null) { TEUCHOS_TEST_FOR_EXCEPTION(stridedDoFullMap==Teuchos::null, Exceptions::BadCast, "MueLu::BlockedPFactory::Build: full map in domain map extractor has no striding information! error."); std::vector<size_t> stridedData2 = stridedDoFullMap->getStridingData(); fullDomainMap = StridedMapFactory::Build( originalTransferOp->getDomainMap()->lib(), Teuchos::OrdinalTraits<Xpetra::global_size_t>::invalid(), fullDomainMapGIDs, domainIndexBase, stridedData2, originalTransferOp->getDomainMap()->getComm(), stridedDoFullMap->getStridedBlockId(), stridedDoFullMap->getOffset()); } else { fullDomainMap = MapFactory::Build( originalTransferOp->getDomainMap()->lib(), Teuchos::OrdinalTraits<Xpetra::global_size_t>::invalid(), fullDomainMapGIDs, domainIndexBase, originalTransferOp->getDomainMap()->getComm()); } // build map extractors Teuchos::RCP<const Xpetra::MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node> > rangeMapExtractor = Xpetra::MapExtractorFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>::Build(fullRangeMap, subBlockRRangeMaps); Teuchos::RCP<const Xpetra::MapExtractor<Scalar, LocalOrdinal, GlobalOrdinal, Node> > domainMapExtractor = Xpetra::MapExtractorFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>::Build(fullDomainMap, subBlockRDomainMaps); Teuchos::RCP<BlockedCrsMatrix> bRebR = Teuchos::rcp(new BlockedCrsMatrix(rangeMapExtractor,domainMapExtractor,10)); for(size_t i = 0; i<subBlockRRangeMaps.size(); i++) { Teuchos::RCP<const CrsMatrixWrap> crsOpii = Teuchos::rcp_dynamic_cast<const CrsMatrixWrap>(subBlockRebR[i]); Teuchos::RCP<CrsMatrix> crsMatii = crsOpii->getCrsMatrix(); bRebR->setMatrix(i,i,crsMatii); } bRebR->fillComplete(); Set(coarseLevel, "R", Teuchos::rcp_dynamic_cast<Matrix>(bRebR)); // do nothing // TODO remove this! } // Build
Albany::MultiSTKFieldContainer<Interleaved>::MultiSTKFieldContainer( const Teuchos::RCP<Teuchos::ParameterList>& params_, const Teuchos::RCP<stk::mesh::MetaData>& metaData_, const Teuchos::RCP<stk::mesh::BulkData>& bulkData_, const int neq_, const AbstractFieldContainer::FieldContainerRequirements& req, const int numDim_, const Teuchos::RCP<Albany::StateInfoStruct>& sis, const Teuchos::Array<Teuchos::Array<std::string> >& solution_vector, const Teuchos::Array<std::string>& residual_vector) : GenericSTKFieldContainer<Interleaved>(params_, metaData_, bulkData_, neq_, numDim_), haveResidual(false), buildSphereVolume(false) { typedef typename AbstractSTKFieldContainer::VectorFieldType VFT; typedef typename AbstractSTKFieldContainer::ScalarFieldType SFT; typedef typename AbstractSTKFieldContainer::SphereVolumeFieldType SVFT; sol_vector_name.resize(solution_vector.size()); sol_index.resize(solution_vector.size()); // Check the input for(int vec_num = 0; vec_num < solution_vector.size(); vec_num++){ if(solution_vector[vec_num].size() == 0) { // Do the default solution vector std::string name = params_->get<std::string>(sol_tag_name[vec_num], sol_id_name[vec_num]); VFT* solution = & metaData_->declare_field< VFT >(stk::topology::NODE_RANK, name); stk::mesh::put_field(*solution, metaData_->universal_part(), neq_); #ifdef ALBANY_SEACAS stk::io::set_field_role(*solution, Ioss::Field::TRANSIENT); #endif sol_vector_name[vec_num].push_back(name); sol_index[vec_num].push_back(this->neq); } else if(solution_vector[vec_num].size() == 1) { // User is just renaming the entire solution vector VFT* solution = & metaData_->declare_field< VFT >(stk::topology::NODE_RANK, solution_vector[vec_num][0]); stk::mesh::put_field(*solution, metaData_->universal_part(), neq_); #ifdef ALBANY_SEACAS stk::io::set_field_role(*solution, Ioss::Field::TRANSIENT); #endif sol_vector_name[vec_num].push_back(solution_vector[vec_num][0]); sol_index[vec_num].push_back(neq_); } else { // user is breaking up the solution into multiple fields // make sure the number of entries is even TEUCHOS_TEST_FOR_EXCEPTION((solution_vector[vec_num].size() % 2), std::logic_error, "Error in input file: specification of solution vector layout is incorrect." << std::endl); int len, accum = 0; for(int i = 0; i < solution_vector[vec_num].size(); i += 2) { if(solution_vector[vec_num][i + 1] == "V") { len = numDim_; // vector accum += len; VFT* solution = & metaData_->declare_field< VFT >(stk::topology::NODE_RANK, solution_vector[vec_num][i]); stk::mesh::put_field(*solution, metaData_->universal_part(), len); #ifdef ALBANY_SEACAS stk::io::set_field_role(*solution, Ioss::Field::TRANSIENT); #endif sol_vector_name[vec_num].push_back(solution_vector[vec_num][i]); sol_index[vec_num].push_back(len); } else if(solution_vector[vec_num][i + 1] == "S") { len = 1; // scalar accum += len; SFT* solution = & metaData_->declare_field< SFT >(stk::topology::NODE_RANK, solution_vector[vec_num][i]); stk::mesh::put_field(*solution, metaData_->universal_part()); #ifdef ALBANY_SEACAS stk::io::set_field_role(*solution, Ioss::Field::TRANSIENT); #endif sol_vector_name[vec_num].push_back(solution_vector[vec_num][i]); sol_index[vec_num].push_back(len); } else TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error, "Error in input file: specification of solution vector layout is incorrect." << std::endl); } TEUCHOS_TEST_FOR_EXCEPTION(accum != neq_, std::logic_error, "Error in input file: specification of solution vector layout is incorrect." << std::endl); } } #if defined(ALBANY_LCM) // do the residual next if(residual_vector.size() == 0) { // Do the default residual vector std::string name = params_->get<std::string>(res_tag_name, res_id_name); VFT* residual = & metaData_->declare_field< VFT >(stk::topology::NODE_RANK, name); stk::mesh::put_field(*residual, metaData_->universal_part(), neq_); #ifdef ALBANY_SEACAS stk::io::set_field_role(*residual, Ioss::Field::TRANSIENT); #endif res_vector_name.push_back(name); res_index.push_back(neq_); } else if(residual_vector.size() == 1) { // User is just renaming the entire residual vector VFT* residual = & metaData_->declare_field< VFT >(stk::topology::NODE_RANK, residual_vector[0]); stk::mesh::put_field(*residual, metaData_->universal_part(), neq_); #ifdef ALBANY_SEACAS stk::io::set_field_role(*residual, Ioss::Field::TRANSIENT); #endif res_vector_name.push_back(residual_vector[0]); res_index.push_back(neq_); } else { // user is breaking up the residual into multiple fields // make sure the number of entries is even TEUCHOS_TEST_FOR_EXCEPTION((residual_vector.size() % 2), std::logic_error, "Error in input file: specification of residual vector layout is incorrect." << std::endl); int len, accum = 0; for(int i = 0; i < residual_vector.size(); i += 2) { if(residual_vector[i + 1] == "V") { len = numDim_; // vector accum += len; VFT* residual = & metaData_->declare_field< VFT >(stk::topology::NODE_RANK, residual_vector[i]); stk::mesh::put_field(*residual, metaData_->universal_part(), len); #ifdef ALBANY_SEACAS stk::io::set_field_role(*residual, Ioss::Field::TRANSIENT); #endif res_vector_name.push_back(residual_vector[i]); res_index.push_back(len); } else if(residual_vector[i + 1] == "S") { len = 1; // scalar accum += len; SFT* residual = & metaData_->declare_field< SFT >(stk::topology::NODE_RANK, residual_vector[i]); stk::mesh::put_field(*residual, metaData_->universal_part()); #ifdef ALBANY_SEACAS stk::io::set_field_role(*residual, Ioss::Field::TRANSIENT); #endif res_vector_name.push_back(residual_vector[i]); res_index.push_back(len); } else TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error, "Error in input file: specification of residual vector layout is incorrect." << std::endl); } TEUCHOS_TEST_FOR_EXCEPTION(accum != neq_, std::logic_error, "Error in input file: specification of residual vector layout is incorrect." << std::endl); } haveResidual = true; #endif //Do the coordinates this->coordinates_field = & metaData_->declare_field< VFT >(stk::topology::NODE_RANK, "coordinates"); stk::mesh::put_field(*this->coordinates_field , metaData_->universal_part(), numDim_); #ifdef ALBANY_SEACAS stk::io::set_field_role(*this->coordinates_field, Ioss::Field::MESH); #endif #if defined(ALBANY_LCM) && defined(ALBANY_SEACAS) // sphere volume is a mesh attribute read from a genesis mesh file containing sphere element (used for peridynamics) bool hasSphereVolumeFieldContainerRequirement = (std::find(req.begin(), req.end(), "Sphere Volume") != req.end()); if(hasSphereVolumeFieldContainerRequirement){ this->sphereVolume_field = metaData_->template get_field< SVFT >(stk::topology::ELEMENT_RANK, "volume"); if(this->sphereVolume_field != 0){ buildSphereVolume = true; stk::io::set_field_role(*this->sphereVolume_field, Ioss::Field::ATTRIBUTE); } } #endif this->addStateStructs(sis); initializeSTKAdaptation(); }