// quad tests TEUCHOS_UNIT_TEST(tSquareQuadMeshDOFManager, buildTest_quad_edge_orientations2) { // build global (or serial communicator) #ifdef HAVE_MPI stk::ParallelMachine Comm = MPI_COMM_WORLD; #else stk::ParallelMachine Comm = WHAT_TO_DO_COMM; #endif int numProcs = stk::parallel_machine_size(Comm); int myRank = stk::parallel_machine_rank(Comm); TEUCHOS_ASSERT(numProcs==2); // build a geometric pattern from a single basis RCP<const panzer::FieldPattern> patternI1 = buildFieldPattern<Intrepid2::Basis_HCURL_QUAD_I1_FEM<PHX::exec_space,double,double> >(); RCP<panzer::ConnManager<int,int> > connManager = buildQuadMesh(Comm,2,2,1,1); RCP<panzer::DOFManagerFEI<int,int> > dofManager = rcp(new panzer::DOFManagerFEI<int,int>()); dofManager->setOrientationsRequired(true); TEST_EQUALITY(dofManager->getOrientationsRequired(),true); TEST_EQUALITY(dofManager->getConnManager(),Teuchos::null); dofManager->setConnManager(connManager,MPI_COMM_WORLD); TEST_EQUALITY(dofManager->getConnManager(),connManager); dofManager->addField("b",patternI1); dofManager->buildGlobalUnknowns(); dofManager->printFieldInformation(out); const std::vector<int> & b_offsets = dofManager->getGIDFieldOffsets("eblock-0_0",dofManager->getFieldNum("b")); TEST_EQUALITY(b_offsets.size(),4); // unfortunatly this mesh is completly uniform double standardO[] = { 1.0, 1.0, -1.0, -1.0 }; if(myRank==0) { std::vector<double> orientation; // element 0 dofManager->getElementOrientation(0,orientation); TEST_EQUALITY(orientation.size(),4); for(std::size_t i=0;i<4;i++) TEST_EQUALITY(orientation[i],standardO[i]); // element 1 dofManager->getElementOrientation(1,orientation); TEST_EQUALITY(orientation.size(),4); for(std::size_t i=0;i<4;i++) TEST_EQUALITY(orientation[i],standardO[i]); } else if(myRank==1) { std::vector<double> orientation; // element 0 dofManager->getElementOrientation(0,orientation); TEST_EQUALITY(orientation.size(),4); for(std::size_t i=0;i<4;i++) TEST_EQUALITY(orientation[i],standardO[i]); // element 1 dofManager->getElementOrientation(1,orientation); TEST_EQUALITY(orientation.size(),4); for(std::size_t i=0;i<4;i++) TEST_EQUALITY(orientation[i],standardO[i]); } }
// quad tests TEUCHOS_UNIT_TEST(tCubeHexMeshDOFManager, buildTest_hex) { // build global (or serial communicator) #ifdef HAVE_MPI stk::ParallelMachine Comm = MPI_COMM_WORLD; #else stk::ParallelMachine Comm = WHAT_TO_DO_COMM; #endif int numProcs = stk::parallel_machine_size(Comm); int myRank = stk::parallel_machine_rank(Comm); TEUCHOS_ASSERT(numProcs<=2); // build a geometric pattern from a single basis RCP<const panzer::FieldPattern> patternC1 = buildFieldPattern<Intrepid::Basis_HGRAD_HEX_C1_FEM<double,FieldContainer> >(); Teuchos::RCP<panzer_stk::STK_Interface> mesh = buildQuadMesh(Comm,2,2,2,1,1,1); RCP<panzer::ConnManager<int,int> > connManager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh)); RCP<panzer::DOFManager<int,int> > dofManager = rcp(new panzer::DOFManager<int,int>()); TEST_EQUALITY(dofManager->getOrientationsRequired(),false); TEST_EQUALITY(dofManager->getConnManager(),Teuchos::null); dofManager->setConnManager(connManager,MPI_COMM_WORLD); TEST_EQUALITY(dofManager->getConnManager(),connManager); dofManager->addField("ux",patternC1); dofManager->addField("uy",patternC1); dofManager->addField("p",patternC1); std::vector<std::string> fieldOrder; fieldOrder.push_back("ux"); fieldOrder.push_back("uy"); fieldOrder.push_back("p"); dofManager->setFieldOrder(fieldOrder); dofManager->buildGlobalUnknowns(); dofManager->printFieldInformation(out); if(numProcs==1) { std::vector<int> gids_v; int * gids = 0; TEST_ASSERT(false); // element 0 dofManager->getElementGIDs(0,gids_v); gids = &gids_v[0]; TEST_EQUALITY(gids_v.size(),24); TEST_EQUALITY(gids[0],0); TEST_EQUALITY(gids[1],1); TEST_EQUALITY(gids[2],2); TEST_EQUALITY(gids[3],3); TEST_EQUALITY(gids[4],4); TEST_EQUALITY(gids[5],5); TEST_EQUALITY(gids[6],12); TEST_EQUALITY(gids[7],13); TEST_EQUALITY(gids[8],14); TEST_EQUALITY(gids[9], 9); TEST_EQUALITY(gids[10],10); TEST_EQUALITY(gids[11],11); gids = &gids_v[12]; TEST_EQUALITY(gids[0],27); TEST_EQUALITY(gids[1],28); TEST_EQUALITY(gids[2],29); TEST_EQUALITY(gids[3],30); TEST_EQUALITY(gids[4],31); TEST_EQUALITY(gids[5],32); TEST_EQUALITY(gids[6],39); TEST_EQUALITY(gids[7],40); TEST_EQUALITY(gids[8],41); TEST_EQUALITY(gids[9],36); TEST_EQUALITY(gids[10],37); TEST_EQUALITY(gids[11],38); // element 6 dofManager->getElementGIDs(mesh->elementLocalId(5),gids_v); gids = &gids_v[0]; TEST_EQUALITY(gids_v.size(),24); TEST_EQUALITY(gids[0],27); TEST_EQUALITY(gids[1],28); TEST_EQUALITY(gids[2],29); TEST_EQUALITY(gids[3],30); TEST_EQUALITY(gids[4],31); TEST_EQUALITY(gids[5],32); TEST_EQUALITY(gids[6],39); TEST_EQUALITY(gids[7],40); TEST_EQUALITY(gids[8],41); TEST_EQUALITY(gids[9],36); TEST_EQUALITY(gids[10],37); TEST_EQUALITY(gids[11],38); gids = &gids_v[12]; TEST_EQUALITY(gids[0],54); TEST_EQUALITY(gids[1],55); TEST_EQUALITY(gids[2],56); TEST_EQUALITY(gids[3],57); TEST_EQUALITY(gids[4],58); TEST_EQUALITY(gids[5],59); TEST_EQUALITY(gids[6],66); TEST_EQUALITY(gids[7],67); TEST_EQUALITY(gids[8],68); TEST_EQUALITY(gids[9],63); TEST_EQUALITY(gids[10],64); TEST_EQUALITY(gids[11],65); } else if(myRank==0) { // element 7 const int * gids = connManager->getConnectivity(mesh->elementLocalId(7)); TEST_EQUALITY(connManager->getConnectivitySize(mesh->elementLocalId(7)),8); TEST_EQUALITY(gids[0],12); TEST_EQUALITY(gids[1],13); TEST_EQUALITY(gids[2],16); TEST_EQUALITY(gids[3],15); TEST_EQUALITY(gids[4],21); TEST_EQUALITY(gids[5],22); TEST_EQUALITY(gids[6],25); TEST_EQUALITY(gids[7],24); } else if(myRank==1) { // element 2 const int * gids = connManager->getConnectivity(mesh->elementLocalId(2)); TEST_EQUALITY(connManager->getConnectivitySize(mesh->elementLocalId(2)),8); TEST_EQUALITY(gids[0],1); TEST_EQUALITY(gids[1],2); TEST_EQUALITY(gids[2],5); TEST_EQUALITY(gids[3],4); TEST_EQUALITY(gids[4],10); TEST_EQUALITY(gids[5],11); TEST_EQUALITY(gids[6],14); TEST_EQUALITY(gids[7],13); } }
// quad tests TEUCHOS_UNIT_TEST(tSquareQuadMeshDOFManager_edgetests, buildTest_quad_edge_orientations_fail) { // build global (or serial communicator) #ifdef HAVE_MPI stk_classic::ParallelMachine Comm = MPI_COMM_WORLD; #else stk_classic::ParallelMachine Comm = WHAT_TO_DO_COMM; #endif int numProcs = stk_classic::parallel_machine_size(Comm); TEUCHOS_ASSERT(numProcs==1); // build a geometric pattern from a single basis RCP<const panzer::FieldPattern> patternI1 = buildFieldPattern<Intrepid2::Basis_HCURL_QUAD_I1_FEM<double,FieldContainer> >(); out << *patternI1 << std::endl; RCP<panzer::ConnManager<int,int> > connManager = buildQuadMesh(Comm,2,2,1,1); RCP<panzer::DOFManagerFEI<int,int> > dofManager = rcp(new panzer::DOFManagerFEI<int,int>()); dofManager->setOrientationsRequired(true); TEST_EQUALITY(dofManager->getOrientationsRequired(),true); TEST_EQUALITY(dofManager->getConnManager(),Teuchos::null); dofManager->setConnManager(connManager,MPI_COMM_WORLD); TEST_EQUALITY(dofManager->getConnManager(),connManager); dofManager->addField("b",patternI1); dofManager->buildGlobalUnknowns(); for(int i=0;i<4;i++) { const int * indices = connManager->getConnectivity(i); TEST_EQUALITY(connManager->getConnectivitySize(i),8); out << "cell = " << i << ": "; for(int j=0;j<4;j++) out << indices[j+4] << " "; out << std::endl; } out << "GIDS" << std::endl; for(int i=0;i<4;i++) { std::vector<int> gids; dofManager->getElementGIDs(i,gids); TEST_EQUALITY(gids.size(),4); out << "cell = " << i << ": "; for(int j=0;j<4;j++) out << gids[j] << " "; out << std::endl; } std::vector<int> total; dofManager->getOwnedIndices(total); TEST_EQUALITY(total.size(),12); dofManager->printFieldInformation(out); }
// quad tests TEUCHOS_UNIT_TEST(tSquareTriMeshDOFManager, buildTest_tri) { PHX::InitializeKokkosDevice(); // build global (or serial communicator) #ifdef HAVE_MPI stk_classic::ParallelMachine Comm = MPI_COMM_WORLD; #else stk_classic::ParallelMachine Comm = WHAT_TO_DO_COMM; #endif int numProcs = stk_classic::parallel_machine_size(Comm); int myRank = stk_classic::parallel_machine_rank(Comm); TEUCHOS_ASSERT(numProcs==2); // build a geometric pattern from a single basis RCP<const panzer::FieldPattern> patternC1 = buildFieldPattern<Intrepid2::Basis_HGRAD_TRI_C1_FEM<double,FieldContainer> >(); RCP<panzer::ConnManager<int,int> > connManager = buildTriMesh(Comm,2,2,1,1); RCP<panzer::DOFManagerFEI<int,int> > dofManager = rcp(new panzer::DOFManagerFEI<int,int>()); TEST_EQUALITY(dofManager->getOrientationsRequired(),false); TEST_EQUALITY(dofManager->getConnManager(),Teuchos::null); dofManager->setConnManager(connManager,MPI_COMM_WORLD); TEST_EQUALITY(dofManager->getConnManager(),connManager); dofManager->addField("ux",patternC1); dofManager->addField("uy",patternC1); dofManager->addField("p",patternC1); dofManager->buildGlobalUnknowns(); dofManager->printFieldInformation(out); TEST_EQUALITY(dofManager->getFieldNum("p"),0); TEST_EQUALITY(dofManager->getFieldNum("ux"),1); TEST_EQUALITY(dofManager->getFieldNum("uy"),2); const std::vector<int> & uy_offsets = dofManager->getGIDFieldOffsets("eblock-0_0",dofManager->getFieldNum("uy")); const std::vector<int> & p_offsets = dofManager->getGIDFieldOffsets("eblock-0_0",dofManager->getFieldNum("p")); const std::vector<int> & ux_offsets = dofManager->getGIDFieldOffsets("eblock-0_0",dofManager->getFieldNum("ux")); TEST_EQUALITY(uy_offsets.size(),p_offsets.size()); TEST_EQUALITY(uy_offsets.size(),ux_offsets.size()); if(myRank==0) { std::vector<int> gids; dofManager->getElementGIDs(0,gids); TEST_EQUALITY(gids.size(),9); TEST_EQUALITY(gids[0],0); TEST_EQUALITY(gids[1],1); TEST_EQUALITY(gids[2],2); TEST_EQUALITY(gids[3],3); TEST_EQUALITY(gids[4],4); TEST_EQUALITY(gids[5],5); TEST_EQUALITY(gids[6],9); TEST_EQUALITY(gids[7],10); TEST_EQUALITY(gids[8],11); for(std::size_t i=0;i<p_offsets.size();i++) { TEST_ASSERT(gids[p_offsets[i]]<gids[ux_offsets[i]]); TEST_ASSERT(gids[p_offsets[i]]<gids[uy_offsets[i]]); TEST_ASSERT(gids[ux_offsets[i]]<gids[uy_offsets[i]]); } dofManager->getElementGIDs(1,gids); TEST_EQUALITY(gids.size(),9); TEST_EQUALITY(gids[0],0); TEST_EQUALITY(gids[1],1); TEST_EQUALITY(gids[2],2); TEST_EQUALITY(gids[3],9); TEST_EQUALITY(gids[4],10); TEST_EQUALITY(gids[5],11); TEST_EQUALITY(gids[6],6); TEST_EQUALITY(gids[7],7); TEST_EQUALITY(gids[8],8); for(std::size_t i=0;i<p_offsets.size();i++) { TEST_ASSERT(gids[p_offsets[i]]<gids[ux_offsets[i]]); TEST_ASSERT(gids[p_offsets[i]]<gids[uy_offsets[i]]); TEST_ASSERT(gids[ux_offsets[i]]<gids[uy_offsets[i]]); } dofManager->getElementGIDs(3,gids); TEST_EQUALITY(gids.size(),9); TEST_EQUALITY(gids[0],6); TEST_EQUALITY(gids[1],7); TEST_EQUALITY(gids[2],8); TEST_EQUALITY(gids[3],15); TEST_EQUALITY(gids[4],16); TEST_EQUALITY(gids[5],17); TEST_EQUALITY(gids[6],12); TEST_EQUALITY(gids[7],13); TEST_EQUALITY(gids[8],14); for(std::size_t i=0;i<p_offsets.size();i++) { TEST_ASSERT(gids[p_offsets[i]]<gids[ux_offsets[i]]); TEST_ASSERT(gids[p_offsets[i]]<gids[uy_offsets[i]]); TEST_ASSERT(gids[ux_offsets[i]]<gids[uy_offsets[i]]); } } else if(myRank==1) { std::vector<int> gids; dofManager->getElementGIDs(0,gids); TEST_EQUALITY(gids.size(),9); TEST_EQUALITY(gids[0],3); TEST_EQUALITY(gids[1],4); TEST_EQUALITY(gids[2],5); TEST_EQUALITY(gids[3],18); TEST_EQUALITY(gids[4],19); TEST_EQUALITY(gids[5],20); TEST_EQUALITY(gids[6],21); TEST_EQUALITY(gids[7],22); TEST_EQUALITY(gids[8],23); for(std::size_t i=0;i<p_offsets.size();i++) { TEST_ASSERT(gids[p_offsets[i]]<gids[ux_offsets[i]]); TEST_ASSERT(gids[p_offsets[i]]<gids[uy_offsets[i]]); TEST_ASSERT(gids[ux_offsets[i]]<gids[uy_offsets[i]]); } dofManager->getElementGIDs(1,gids); TEST_EQUALITY(gids.size(),9); TEST_EQUALITY(gids[0],3); TEST_EQUALITY(gids[1],4); TEST_EQUALITY(gids[2],5); TEST_EQUALITY(gids[3],21); TEST_EQUALITY(gids[4],22); TEST_EQUALITY(gids[5],23); TEST_EQUALITY(gids[6],9); TEST_EQUALITY(gids[7],10); TEST_EQUALITY(gids[8],11); for(std::size_t i=0;i<p_offsets.size();i++) { TEST_ASSERT(gids[p_offsets[i]]<gids[ux_offsets[i]]); TEST_ASSERT(gids[p_offsets[i]]<gids[uy_offsets[i]]); TEST_ASSERT(gids[ux_offsets[i]]<gids[uy_offsets[i]]); } dofManager->getElementGIDs(3,gids); TEST_EQUALITY(gids.size(),9); TEST_EQUALITY(gids[0],9); TEST_EQUALITY(gids[1],10); TEST_EQUALITY(gids[2],11); TEST_EQUALITY(gids[3],24); TEST_EQUALITY(gids[4],25); TEST_EQUALITY(gids[5],26); TEST_EQUALITY(gids[6],15); TEST_EQUALITY(gids[7],16); TEST_EQUALITY(gids[8],17); for(std::size_t i=0;i<p_offsets.size();i++) { TEST_ASSERT(gids[p_offsets[i]]<gids[ux_offsets[i]]); TEST_ASSERT(gids[p_offsets[i]]<gids[uy_offsets[i]]); TEST_ASSERT(gids[ux_offsets[i]]<gids[uy_offsets[i]]); } } PHX::FinalizeKokkosDevice(); }
void evaluateFields(typename Traits::EvalData d) { std::cout << "unspecialized version of \"ScatterResidual_BlockedTpetra::evaluateFields\" on \""+PHX::TypeString<EvalT>::value+"\" should not be used!" << std::endl; TEUCHOS_ASSERT(false); }
int getElementBlockGIDCount(const std::size_t &) const { TEUCHOS_ASSERT(false); }
inline void panzer::BasisValues<Scalar,Array>:: evaluateValues(const Array& cub_points, const Array& jac, const Array& jac_det, const Array& jac_inv, const Array& weighted_measure, const Array& node_coordinates) { bool buildWeighted = ((&weighted_measure)!= &dummyArray); bool buildBasisPoints = ((&node_coordinates)!= &dummyArray); // first grab basis descriptor PureBasis::EElementSpace elmtspace = getElementSpace(); int spaceDim = basis_layout->dimension(); intrepid_basis->getValues(basis_ref, cub_points, Intrepid::OPERATOR_VALUE); if(elmtspace==PureBasis::CONST) { Intrepid::FunctionSpaceTools:: HGRADtransformVALUE<Scalar>(basis, basis_ref); if(buildWeighted) { Intrepid::FunctionSpaceTools:: multiplyMeasure<Scalar>(weighted_basis, weighted_measure, basis); } } else if(elmtspace==PureBasis::HGRAD) { intrepid_basis->getValues(grad_basis_ref, cub_points, Intrepid::OPERATOR_GRAD); Intrepid::FunctionSpaceTools:: HGRADtransformVALUE<Scalar>(basis, basis_ref); Intrepid::FunctionSpaceTools:: HGRADtransformGRAD<Scalar>(grad_basis, jac_inv, grad_basis_ref); if(buildWeighted) { Intrepid::FunctionSpaceTools:: multiplyMeasure<Scalar>(weighted_basis, weighted_measure, basis); Intrepid::FunctionSpaceTools:: multiplyMeasure<Scalar>(weighted_grad_basis, weighted_measure, grad_basis); } } else if(elmtspace==PureBasis::HCURL) { intrepid_basis->getValues(curl_basis_ref, cub_points, Intrepid::OPERATOR_CURL); Intrepid::FunctionSpaceTools:: HCURLtransformVALUE<Scalar>(basis, jac_inv, basis_ref); // the CURL transform differs depending on spactial dimension // "In 2D the de Rham complex collapses." But I look at it like this: // In 2D the curl is simply $-\partial_x u_1+\partial_y u_0$ which // has the same derivative structure as the divergence in 2D // $\partial_x u_0 + \partial_y u_1$ which means the transformation // is the same. if(spaceDim==2) Intrepid::FunctionSpaceTools:: HDIVtransformDIV<Scalar>(curl_basis, jac_det, // note only volume deformation is needed! // this relates directly to this being in // the divergence space in 2D! curl_basis_ref); else if(spaceDim==3) Intrepid::FunctionSpaceTools:: HCURLtransformCURL<Scalar>(curl_basis, jac, jac_det, curl_basis_ref); else TEUCHOS_ASSERT(false); // what you doin? if(buildWeighted) { Intrepid::FunctionSpaceTools:: multiplyMeasure<Scalar>(weighted_basis, weighted_measure, basis); Intrepid::FunctionSpaceTools:: multiplyMeasure<Scalar>(weighted_curl_basis, weighted_measure, curl_basis); } } // If basis supports coordinate values at basis points, then // compute these values if(buildBasisPoints) { Teuchos::RCP<Intrepid::DofCoordsInterface<Array> > coords; coords = Teuchos::rcp_dynamic_cast<Intrepid::DofCoordsInterface<Array> >(intrepid_basis); if (!Teuchos::is_null(coords)) { coords->getDofCoords(basis_coordinates_ref); Intrepid::CellTools<Scalar> cell_tools; cell_tools.mapToPhysicalFrame(basis_coordinates, basis_coordinates_ref, node_coordinates, intrepid_basis->getBaseCellTopology()); } } }
/** \brief Get the number used for access to this * field * * Get the number used for access to this * field. This is used as the input parameter * to the other functions that provide access * to the global unknowns. * * \param[in] str Human readable name of the field * * \returns A unique integer associated with the * field if the field exisits. Otherwise * a -1 is returned. */ virtual int getFieldNum(const std::string & str) const { TEUCHOS_ASSERT(false); return -1; }
virtual const std::string & getFieldString(int field) const { TEUCHOS_ASSERT(false); static std::string empty = "EMPTY"; return empty; }
void panzer::ScatterDirichletResidual_Tpetra<panzer::Traits::SGJacobian, TRAITS,LO,GO,NodeT>:: evaluateFields(typename TRAITS::EvalData workset) { /* typedef SGTpetraLinearObjContainer<double,LO,GO,NodeT> SGLOC; std::vector<GO> GIDs; std::vector<LO> LIDs; // for convenience pull out some objects from workset std::string blockId = this->wda(workset).block_id; const std::vector<std::size_t> & localCellIds = this->wda(workset).cell_local_ids; Teuchos::RCP<typename LOC::CrsMatrixType> Jac_template = (*sgTpetraContainer_->begin())->get_A(); Teuchos::RCP<const typename LOC::MapType> map = Jac_template->getRowMap(); Teuchos::ArrayRCP<double> dc_array = dirichletCounter_->get1dViewNonConst(); // NOTE: A reordering of these loops will likely improve performance // The "getGIDFieldOffsets may be expensive. However the // "getElementGIDs" can be cheaper. However the lookup for LIDs // may be more expensive! // scatter operation for each cell in workset for(std::size_t worksetCellIndex=0;worksetCellIndex<localCellIds.size();++worksetCellIndex) { std::size_t cellLocalId = localCellIds[worksetCellIndex]; globalIndexer_->getElementGIDs(cellLocalId,GIDs); // caculate the local IDs for this element LIDs.resize(GIDs.size()); for(std::size_t i=0;i<GIDs.size();i++) LIDs[i] = map->getLocalElement(GIDs[i]); std::vector<bool> is_owned(GIDs.size(), false); globalIndexer_->ownedIndices(GIDs,is_owned); // loop over each field to be scattered for(std::size_t fieldIndex = 0; fieldIndex < scatterFields_.size(); fieldIndex++) { int fieldNum = fieldIds_[fieldIndex]; // this call "should" get the right ordering according to the Intrepid basis const std::pair<std::vector<int>,std::vector<int> > & indicePair = globalIndexer_->getGIDFieldOffsets_closure(blockId,fieldNum, side_subcell_dim_, local_side_id_); const std::vector<int> & elmtOffset = indicePair.first; const std::vector<int> & basisIdMap = indicePair.second; // loop over basis functions for(std::size_t basis=0;basis<elmtOffset.size();basis++) { int offset = elmtOffset[basis]; LO lid = LIDs[offset]; GO gid = GIDs[offset]; int basisId = basisIdMap[basis]; if(lid<0) // not on this processor continue; const ScalarT scatterField = (scatterFields_[fieldIndex])(worksetCellIndex,basisId); // loop over stochastic basis scatter field values to residual vectors int stochIndex = 0; typename SGLOC::iterator itr; for(itr=sgTpetraContainer_->begin();itr!=sgTpetraContainer_->end();++itr,++stochIndex) { Teuchos::RCP<typename LOC::VectorType> r = (*itr)->get_f(); Teuchos::RCP<typename LOC::CrsMatrixType> Jac = (*itr)->get_A(); Teuchos::ArrayRCP<double> r_array = r->get1dViewNonConst(); // zero out matrix row { std::size_t sz = Jac->getNumEntriesInLocalRow(lid); std::size_t numEntries = 0; Teuchos::Array<LO> rowIndices(sz); Teuchos::Array<double> rowValues(sz); Jac->getLocalRowCopy(lid,rowIndices,rowValues,numEntries); for(std::size_t i=0;i<numEntries;i++) rowValues[i] = 0.0; Jac->replaceLocalValues(lid,rowIndices,rowValues); } r_array[lid] = scatterField.val().coeff(stochIndex); // loop over the sensitivity indices: all DOFs on a cell std::vector<double> jacRow(scatterField.size(),0.0); for(int sensIndex=0;sensIndex<scatterField.size();++sensIndex) jacRow[sensIndex] = scatterField.fastAccessDx(sensIndex).coeff(stochIndex); Jac->replaceGlobalValues(gid, GIDs, jacRow); } // dirichlet condition application dc_array[lid] = 1.0; } } } */ TEUCHOS_ASSERT(false); // lets face it this doesn't work }
void evaluateFields(typename TRAITS::EvalData d) { std::cout << "unspecialized version of \"GatherSolution_BlockedEpetra::evaluateFields\" on "+PHX::typeAsString<EvalT>()+"\" should not be used!" << std::endl; TEUCHOS_ASSERT(false); }
void IntegrationValues2<Scalar>:: evaluateRemainingValues(const PHX::MDField<Scalar,Cell,NODE,Dim>& in_node_coordinates) { Intrepid2::CellTools<PHX::Device::execution_space> cell_tools; // copy the dynamic data structures into the static data structures { size_type num_ip = dyn_cub_points.dimension(0); size_type num_dims = dyn_cub_points.dimension(1); for (size_type ip = 0; ip < num_ip; ++ip) { cub_weights(ip) = dyn_cub_weights(ip); for (size_type dim = 0; dim < num_dims; ++dim) cub_points(ip,dim) = dyn_cub_points(ip,dim); } } if (int_rule->isSide()) { const size_type num_ip = dyn_cub_points.dimension(0), num_side_dims = dyn_side_cub_points.dimension(1); for (size_type ip = 0; ip < num_ip; ++ip) for (size_type dim = 0; dim < num_side_dims; ++dim) side_cub_points(ip,dim) = dyn_side_cub_points(ip,dim); } { size_type num_cells = in_node_coordinates.dimension(0); size_type num_nodes = in_node_coordinates.dimension(1); size_type num_dims = in_node_coordinates.dimension(2); for (size_type cell = 0; cell < num_cells; ++cell) { for (size_type node = 0; node < num_nodes; ++node) { for (size_type dim = 0; dim < num_dims; ++dim) { node_coordinates(cell,node,dim) = in_node_coordinates(cell,node,dim); } } } } cell_tools.setJacobian(jac.get_view(), cub_points.get_view(), node_coordinates.get_view(), *(int_rule->topology)); cell_tools.setJacobianInv(jac_inv.get_view(), jac.get_view()); cell_tools.setJacobianDet(jac_det.get_view(), jac.get_view()); if (!int_rule->isSide()) { Intrepid2::FunctionSpaceTools<PHX::Device::execution_space>:: computeCellMeasure(weighted_measure.get_view(), jac_det.get_view(), cub_weights.get_view()); } else if(int_rule->spatial_dimension==3) { Intrepid2::FunctionSpaceTools<PHX::Device::execution_space>:: computeFaceMeasure(weighted_measure.get_view(), jac.get_view(), cub_weights.get_view(), int_rule->side, *int_rule->topology, scratch_for_compute_side_measure.get_view()); } else if(int_rule->spatial_dimension==2) { Intrepid2::FunctionSpaceTools<PHX::Device::execution_space>:: computeEdgeMeasure(weighted_measure.get_view(), jac.get_view(), cub_weights.get_view(), int_rule->side,*int_rule->topology, scratch_for_compute_side_measure.get_view()); } else TEUCHOS_ASSERT(false); // Shakib contravarient metric tensor for (size_type cell = 0; cell < contravarient.dimension(0); ++cell) { for (size_type ip = 0; ip < contravarient.dimension(1); ++ip) { // zero out matrix for (size_type i = 0; i < contravarient.dimension(2); ++i) for (size_type j = 0; j < contravarient.dimension(3); ++j) covarient(cell,ip,i,j) = 0.0; // g^{ij} = \frac{\parital x_i}{\partial \chi_\alpha}\frac{\parital x_j}{\partial \chi_\alpha} for (size_type i = 0; i < contravarient.dimension(2); ++i) { for (size_type j = 0; j < contravarient.dimension(3); ++j) { for (size_type alpha = 0; alpha < contravarient.dimension(2); ++alpha) { covarient(cell,ip,i,j) += jac(cell,ip,i,alpha) * jac(cell,ip,j,alpha); } } } } } Intrepid2::RealSpaceTools<PHX::Device::execution_space>::inverse(contravarient.get_view(), covarient.get_view()); // norm of g_ij for (size_type cell = 0; cell < contravarient.dimension(0); ++cell) { for (size_type ip = 0; ip < contravarient.dimension(1); ++ip) { norm_contravarient(cell,ip) = 0.0; for (size_type i = 0; i < contravarient.dimension(2); ++i) { for (size_type j = 0; j < contravarient.dimension(3); ++j) { norm_contravarient(cell,ip) += contravarient(cell,ip,i,j) * contravarient(cell,ip,i,j); } } norm_contravarient(cell,ip) = std::sqrt(norm_contravarient(cell,ip)); } } }
inline void panzer::IntegrationValues<Scalar,Array>:: evaluateValues(const NodeCoordinateArray& in_node_coordinates) { int num_space_dim = int_rule->topology->getDimension(); if (int_rule->isSide() && num_space_dim==1) { std::cout << "WARNING: 0-D quadrature rule ifrastructure does not exist!!! Will not be able to do " << "non-natural integration rules."; return; } Intrepid::CellTools<Scalar> cell_tools; if (!int_rule->isSide()) intrepid_cubature->getCubature(cub_points, cub_weights); else { intrepid_cubature->getCubature(side_cub_points, cub_weights); cell_tools.mapToReferenceSubcell(cub_points, side_cub_points, int_rule->spatial_dimension-1, int_rule->side, *(int_rule->topology)); } { typedef typename panzer::ArrayTraits<Scalar,NodeCoordinateArray>::size_type size_type; size_type num_cells = in_node_coordinates.dimension(0); size_type num_nodes = in_node_coordinates.dimension(1); size_type num_dims = in_node_coordinates.dimension(2); for (size_type cell = 0; cell < num_cells; ++cell) { for (size_type node = 0; node < num_nodes; ++node) { for (size_type dim = 0; dim < num_dims; ++dim) { node_coordinates(cell,node,dim) = in_node_coordinates(cell,node,dim); } } } } cell_tools.setJacobian(jac, cub_points, node_coordinates, *(int_rule->topology)); cell_tools.setJacobianInv(jac_inv, jac); cell_tools.setJacobianDet(jac_det, jac); if (!int_rule->isSide()) { Intrepid::FunctionSpaceTools:: computeCellMeasure<Scalar>(weighted_measure, jac_det, cub_weights); } else if(int_rule->spatial_dimension==3) { Intrepid::FunctionSpaceTools:: computeFaceMeasure<Scalar>(weighted_measure, jac, cub_weights,int_rule->side,*int_rule->topology); } else if(int_rule->spatial_dimension==2) { Intrepid::FunctionSpaceTools:: computeEdgeMeasure<Scalar>(weighted_measure, jac, cub_weights,int_rule->side,*int_rule->topology); } else TEUCHOS_ASSERT(false); // Shakib contravarient metric tensor typedef typename panzer::ArrayTraits<Scalar,Array>::size_type size_type; for (size_type cell = 0; cell < contravarient.dimension(0); ++cell) { for (size_type ip = 0; ip < contravarient.dimension(1); ++ip) { // zero out matrix for (size_type i = 0; i < contravarient.dimension(2); ++i) for (size_type j = 0; j < contravarient.dimension(3); ++j) covarient(cell,ip,i,j) = 0.0; // g^{ij} = \frac{\parital x_i}{\partial \chi_\alpha}\frac{\parital x_j}{\partial \chi_\alpha} for (size_type i = 0; i < contravarient.dimension(2); ++i) { for (size_type j = 0; j < contravarient.dimension(3); ++j) { for (size_type alpha = 0; alpha < contravarient.dimension(2); ++alpha) { covarient(cell,ip,i,j) += jac(cell,ip,i,alpha) * jac(cell,ip,j,alpha); } } } } } Intrepid::RealSpaceTools<Scalar>::inverse(contravarient, covarient); /* for (std::size_t cell = 0; cell < contravarient.dimension(0); ++cell) { std::cout << "cell = " << cell << std::endl; for (std::size_t ip = 0; ip < contravarient.dimension(1); ++ip) { std::cout << " ip = " << ip << std::endl; for (std::size_t i = 0; i < contravarient.dimension(2); ++i) { for (std::size_t j = 0; j < contravarient.dimension(2); ++j) { std::cout << "contravarient(" << i << "," << j << ") = " << contravarient(cell,ip,i,j) << std::endl; } } } } */ // norm of g_ij for (size_type cell = 0; cell < contravarient.dimension(0); ++cell) { for (size_type ip = 0; ip < contravarient.dimension(1); ++ip) { norm_contravarient(cell,ip) = 0.0; for (size_type i = 0; i < contravarient.dimension(2); ++i) { for (size_type j = 0; j < contravarient.dimension(3); ++j) { norm_contravarient(cell,ip) += contravarient(cell,ip,i,j) * contravarient(cell,ip,i,j); } } norm_contravarient(cell,ip) = std::sqrt(norm_contravarient(cell,ip)); } } // IP coordinates { cell_tools.mapToPhysicalFrame(ip_coordinates, cub_points, node_coordinates, *(int_rule->topology)); } }
//********************************************************************** PHX_EVALUATE_FIELDS(DirichletResidual_EdgeBasis,workset) { if(workset.num_cells<=0) return; residual.deep_copy(ScalarT(0.0)); if(workset.subcell_dim==1) { Intrepid2::CellTools<ScalarT>::getPhysicalEdgeTangents(edgeTan, pointValues.jac, this->wda(workset).subcell_index, *basis->getCellTopology()); for(std::size_t c=0; c<workset.num_cells; c++) { for(int b=0; b<dof.dimension(1); b++) { for(int d=0; d<dof.dimension(2); d++) residual(c,b) += (dof(c,b,d)-value(c,b,d))*edgeTan(c,b,d); } } } else if(workset.subcell_dim==2) { // we need to compute the tangents on each edge for each cell. // how do we do this???? const shards::CellTopology & parentCell = *basis->getCellTopology(); int cellDim = parentCell.getDimension(); int numEdges = dof.dimension(1); refEdgeTan = Intrepid2::FieldContainer<ScalarT>(numEdges,cellDim); for(int i=0; i<numEdges; i++) { Intrepid2::FieldContainer<double> refEdgeTan_local(cellDim); Intrepid2::CellTools<double>::getReferenceEdgeTangent(refEdgeTan_local, i, parentCell); for(int d=0; d<cellDim; d++) refEdgeTan(i,d) = refEdgeTan_local(d); } // Loop over workset faces and edge points for(std::size_t c=0; c<workset.num_cells; c++) { for(int pt = 0; pt < numEdges; pt++) { // Apply parent cell Jacobian to ref. edge tangent for(int i = 0; i < cellDim; i++) { edgeTan(c, pt, i) = 0.0; for(int j = 0; j < cellDim; j++) { edgeTan(c, pt, i) += pointValues.jac(c, pt, i, j)*refEdgeTan(pt,j); }// for j }// for i }// for pt }// for pCell for(std::size_t c=0; c<workset.num_cells; c++) { for(int b=0; b<dof.dimension(1); b++) { for(int d=0; d<dof.dimension(2); d++) residual(c,b) += (dof(c,b,d)-value(c,b,d))*edgeTan(c,b,d); } } } else { // don't know what to do TEUCHOS_ASSERT(false); } // loop over residuals scaling by orientation. This gurantees // everything is oriented in the "positive" direction, this allows // sums acrossed processor to be oriented in the same way (right?) for(std::size_t c=0; c<workset.num_cells; c++) { for(int b=0; b<dof.dimension(1); b++) { residual(c,b) *= dof_orientation(c,b); } } }
/** Get a yes/no on ownership for each index in a vector */ virtual void ownedIndices(const std::vector<std::pair<int,GlobalOrdinalT> > & indices,std::vector<bool> & isOwned) const { TEUCHOS_ASSERT(false); }
virtual Teuchos::RCP<Teuchos::Comm<int> > getComm() const { TEUCHOS_ASSERT(false); return Teuchos::null; }
void getCoordinates(LocalOrdinalT localElementId,Intrepid2::FieldContainer<double> & points) { TEUCHOS_ASSERT(false); }
/** Is the specified field in the element block? */ virtual bool fieldInBlock(const std::string & field, const std::string & block) const { TEUCHOS_ASSERT(false); return false; }
//! \brief Get a particular block. If there is no block at this index location return a new one virtual const Teuchos::RCP<const BlockReorderManager> GetBlock(int blockIndex) const { TEUCHOS_ASSERT(blockIndex<(int) children_.size()); return children_[blockIndex]; }
/** Get field numbers associated with a particular element block. */ virtual const std::vector<int> & getBlockFieldNumbers(const std::string & blockId) const { static std::vector<int> data; TEUCHOS_ASSERT(false); return data; }
// ============================================================================= void VIO::TpetraMesh::Mesh:: computeFvmEntities_() const { // Compute the volume of the (Voronoi) control cells for each point. TEUCHOS_ASSERT( !elems_.is_null() ); int numElems = elems_.size(); Teuchos::RCP<Tpetra::Map<ORD> > map = this->getElemsToNodesMap_(); controlVolumes_ = Teuchos::rcp( new DoubleVector( map ) ); edgeLengths_ = Teuchos::ArrayRCP<Teuchos::ArrayRCP<double> >( numElems ); coedgeLengths_ = Teuchos::ArrayRCP<Teuchos::ArrayRCP<double> >( numElems ); // Teuchos::ArrayRCP<double> controlVolumesView = controlVolumes_->get1dViewNonConst(); // Run over the elements and calculate their contributions to the // control volumes. Teuchos::ArrayRCP<double> cvView = controlVolumes_->get1dViewNonConst(); for ( int k=0; k<numElems; k++ ) { Teuchos::ArrayRCP<ORD> & elem = elems_[k]; TEST_FOR_EXCEPTION( elems_[k].size() != 3, std::runtime_error, "Control volumes can only be constructed consistently with triangular elements." ); // compute the circumcenter Point cc = this->computeCircumcenter_( nodes_[elem[0]], nodes_[elem[1]], nodes_[elem[2]] ); edgeLengths_[k] = Teuchos::ArrayRCP<double>( 3 ); coedgeLengths_[k] = Teuchos::ArrayRCP<double>( 3 ); // iterate over the edges for ( int l=0; l<3; l++ ) { int i0 = elem[ l ]; int i1 = elem[ (l+1)%3 ]; Point & x0 = nodes_[i0]; Point & x1 = nodes_[i1]; // edge midpoint Point mp = this->add_( 0.5, x0, 0.5, x1 ); cvView[ map->getLocalElement(i0) ] += this->getTriangleArea_( x0, cc, mp ); cvView[ map->getLocalElement(i1) ] += this->getTriangleArea_( x1, cc, mp ); coedgeLengths_[k][l] = this->norm2_( this->add_( 1.0, mp, -1.0, cc ) ); edgeLengths_[k][l] = this->norm2_( this->add_( 1.0, x1, -1.0, x0 ) ); } } // sum up the overlapping entries and make sure they're // available on all processes this->sumInOverlapMap_( controlVolumes_ ); // TODO move this to another spot area_ = this->computeDomainArea_(); fvmEntitiesUpToDate_ = true; return; }
/** \brief Get the global IDs for a particular element. This function * overwrites the <code>gids</code> variable. */ virtual void getElementGIDs(LocalOrdinalT localElmtId,std::vector<std::pair<int,GlobalOrdinalT> > & gids,const std::string & blockId="") const { TEUCHOS_ASSERT(false); }
virtual void getElementOrientation(short localElmtId,std::vector<double> & gidsOrientation) const { TEUCHOS_ASSERT(false); }
/** \brief Use the field pattern so that you can find a particular * field in the GIDs array. */ virtual const std::vector<int> & getGIDFieldOffsets(const std::string & blockId,int fieldNum) const { TEUCHOS_ASSERT(false); }
virtual void writeVector(const std::string & identifier,const LinearObjContainer & loc,int id) const { TEUCHOS_ASSERT(false); }
// virtual const std::vector<int> & virtual const std::pair<std::vector<int>,std::vector<int> > & getGIDFieldOffsets_closure(const std::string & blockId, int fieldNum, int subcellDim,int subcellId) const { static std::pair<std::vector<int>,std::vector<int> > p; TEUCHOS_ASSERT(false); return p; }
ordinal_type Stokhos::MonomialProjGramSchmidtPCEBasis<ordinal_type, value_type>:: buildReducedBasis( ordinal_type max_p, value_type threshold, const Teuchos::SerialDenseMatrix<ordinal_type,value_type>& A, const Teuchos::SerialDenseMatrix<ordinal_type,value_type>& F, const Teuchos::Array<value_type>& weights, Teuchos::Array< Stokhos::MultiIndex<ordinal_type> >& terms_, Teuchos::Array<ordinal_type>& num_terms_, Teuchos::SerialDenseMatrix<ordinal_type,value_type>& Qp_, Teuchos::SerialDenseMatrix<ordinal_type,value_type>& Q_) { // Compute basis terms -- 2-D array giving powers for each linear index ordinal_type max_sz; CPBUtils::compute_terms(max_p, this->d, max_sz, terms_, num_terms_); // Compute B matrix -- monomials in F // for i=0,...,nqp-1 // for j=0,...,sz-1 // B(i,j) = F(i,1)^terms_[j][1] * ... * F(i,d)^terms_[j][d] // where sz is the total size of a basis up to order p and terms_[j] // is an array of powers for each term in the total-order basis ordinal_type nqp = weights.size(); SDM B(nqp, max_sz); for (ordinal_type i=0; i<nqp; i++) { for (ordinal_type j=0; j<max_sz; j++) { B(i,j) = 1.0; for (ordinal_type k=0; k<this->d; k++) B(i,j) *= std::pow(F(i,k), terms_[j][k]); } } // Project B into original basis -- should use SPAM for this SDM Bp(this->pce_sz, max_sz); const Teuchos::Array<value_type>& basis_norms = this->pce_basis->norm_squared(); for (ordinal_type i=0; i<this->pce_sz; i++) { for (ordinal_type j=0; j<max_sz; j++) { Bp(i,j) = 0.0; for (ordinal_type k=0; k<nqp; k++) Bp(i,j) += weights[k]*B(k,j)*A(k,i); Bp(i,j) /= basis_norms[i]; } } // Rescale columns of Bp to have unit norm for (ordinal_type j=0; j<max_sz; j++) { value_type nrm = 0.0; for (ordinal_type i=0; i<this->pce_sz; i++) nrm += Bp(i,j)*Bp(i,j)*basis_norms[i]; nrm = std::sqrt(nrm); for (ordinal_type i=0; i<this->pce_sz; i++) Bp(i,j) /= nrm; } // Compute our new basis -- each column of Qp is the coefficients of the // new basis in the original basis. Constraint pivoting so first d+1 // columns and included in Qp. Teuchos::Array<value_type> w(this->pce_sz, 1.0); SDM R; Teuchos::Array<ordinal_type> piv(max_sz); for (int i=0; i<this->d+1; i++) piv[i] = 1; typedef Stokhos::OrthogonalizationFactory<ordinal_type,value_type> SOF; ordinal_type sz_ = SOF::createOrthogonalBasis( this->orthogonalization_method, threshold, this->verbose, Bp, w, Qp_, R, piv); // Evaluate new basis at original quadrature points Q_.reshape(nqp, sz_); ordinal_type ret = Q_.multiply(Teuchos::NO_TRANS, Teuchos::NO_TRANS, 1.0, A, Qp_, 0.0); TEUCHOS_ASSERT(ret == 0); return sz_; }
/** Get set of indices owned and shared by this processor. * This can be thought of as the ``ghosted'' indices. */ virtual void getOwnedAndSharedIndices(std::vector<std::pair<int,GlobalOrdinalT> > & indices) const { TEUCHOS_ASSERT(false); }
void Stokhos::AdaptivityManager:: sumInOperator(Epetra_CrsMatrix & A,const Stokhos::AdaptivityManager::Sparse3TensorHash & Cijk,int k,const Epetra_CrsMatrix & J_k) const { TEUCHOS_ASSERT(J_k.NumMyRows() == int(sg_basis_row_dof_.size())); TEUCHOS_ASSERT(J_k.NumMyCols() == int(sg_basis_col_dof_.size())); const Teuchos::Array<double> & normValues = sg_master_basis_->norm_squared(); // loop over deterministic rows for(int localM=0;localM<J_k.NumMyRows();localM++) { int m = J_k.GRID(localM); // grab row basis Teuchos::RCP<const Stokhos::ProductBasis<int,double> > rowStochBasis = sg_basis_row_dof_[localM]; // grab row from deterministic system int d_numEntries; int * d_Indices; double * d_Values; J_k.ExtractMyRowView(localM,d_numEntries,d_Values,d_Indices); // loop over stochastic degrees of freedom of this row for(int rb_i=0;rb_i<rowStochBasis->size();rb_i++) { int i = sg_master_basis_->index(rowStochBasis->term(rb_i)); double normValue = normValues[i]; // sg_master_basis->norm_squared(i); int sg_m = getGlobalRowId(localM,rb_i); // we wipe out old values, capacity should gurantee // we don't allocate more often than neccessary! std::vector<int> sg_indices; std::vector<double> sg_values; // sg_indices.resize(0); // sg_values.resize(0); // loop over each column for(int colInd=0;colInd<d_numEntries;colInd++) { int localN = d_Indices[colInd]; // grab local deterministic column id // grab row basis Teuchos::RCP<const Stokhos::ProductBasis<int,double> > colStochBasis = sg_basis_col_dof_[localN]; // build values array for(int cb_j=0;cb_j<colStochBasis->size();cb_j++) { int j = sg_master_basis_->index(colStochBasis->term(cb_j)); int sg_n = getGlobalColId(localN,cb_j); double cijk = Cijk.getValue(i,j,k); // no reason to work it in! if(cijk==0) continue; if(scaleOp_) cijk = cijk/normValue; sg_indices.push_back(sg_n); sg_values.push_back(cijk*d_Values[colInd]); } } // add in matrix values A.SumIntoGlobalValues(sg_m,sg_indices.size(),&sg_values[0],&sg_indices[0]); } } }
// quad tests TEUCHOS_UNIT_TEST(tSquareQuadMeshDOFManager, multiple_dof_managers) { // build global (or serial communicator) #ifdef HAVE_MPI stk::ParallelMachine Comm = MPI_COMM_WORLD; #else stk::ParallelMachine Comm = WHAT_TO_DO_COMM; #endif int numProcs = stk::parallel_machine_size(Comm); int myRank = stk::parallel_machine_rank(Comm); TEUCHOS_ASSERT(numProcs==2); // build a geometric pattern from a single basis RCP<const panzer::FieldPattern> patternC1 = buildFieldPattern<Intrepid2::Basis_HGRAD_QUAD_C1_FEM<PHX::exec_space,double,double> >(); RCP<const panzer::FieldPattern> patternC2 = buildFieldPattern<Intrepid2::Basis_HGRAD_QUAD_C2_FEM<PHX::exec_space,double,double> >(); // build DOF manager RCP<panzer::ConnManager<int,int> > connManager = buildQuadMesh(Comm,2,2,1,1); RCP<panzer::DOFManagerFEI<int,int> > dofManager_fluids = rcp(new panzer::DOFManagerFEI<int,int>()); dofManager_fluids->setConnManager(connManager,MPI_COMM_WORLD); dofManager_fluids->addField("ux",patternC2); dofManager_fluids->addField("uy",patternC2); dofManager_fluids->addField("p",patternC1); dofManager_fluids->buildGlobalUnknowns(); RCP<panzer::DOFManagerFEI<int,int> > dofManager_temp = rcp(new panzer::DOFManagerFEI<int,int>()); dofManager_temp->setConnManager(connManager,MPI_COMM_WORLD); dofManager_temp->addField("T",patternC1); dofManager_temp->buildGlobalUnknowns(dofManager_fluids->getGeometricFieldPattern()); if(myRank==0) { std::vector<int> gids; dofManager_temp->getElementGIDs(0,gids); TEST_EQUALITY(gids.size(),4); TEST_EQUALITY(gids[0],0); TEST_EQUALITY(gids[1],1); TEST_EQUALITY(gids[2],3); TEST_EQUALITY(gids[3],2); dofManager_temp->getElementGIDs(1,gids); TEST_EQUALITY(gids.size(),4); TEST_EQUALITY(gids[0],2); TEST_EQUALITY(gids[1],3); TEST_EQUALITY(gids[2],5); TEST_EQUALITY(gids[3],4); } else if(myRank==1) { std::vector<int> gids; dofManager_temp->getElementGIDs(0,gids); TEST_EQUALITY(gids.size(),4); TEST_EQUALITY(gids[0],1); TEST_EQUALITY(gids[1],6); TEST_EQUALITY(gids[2],7); TEST_EQUALITY(gids[3],3); dofManager_temp->getElementGIDs(1,gids); TEST_EQUALITY(gids.size(),4); TEST_EQUALITY(gids[0],3); TEST_EQUALITY(gids[1],7); TEST_EQUALITY(gids[2],8); TEST_EQUALITY(gids[3],5); } else TEUCHOS_ASSERT(false); }