//---------------------------------------------------------------------------// // Map a reference point to the physical space of an entity. void MoabEntityLocalMap::mapToPhysicalFrame( const Entity& entity, const Teuchos::ArrayView<const double>& reference_point, const Teuchos::ArrayView<double>& physical_point ) const { cacheEntity( entity ); DTK_CHECK_ERROR_CODE( d_moab_evaluator->eval( reference_point.getRawPtr(), physical_point.getRawPtr() ) ); }
void MultiVecAdapter<Epetra_MultiVector>::put1dData( const Teuchos::ArrayView<const MultiVecAdapter<Epetra_MultiVector>::scalar_t>& new_data, size_t lda, Teuchos::Ptr< const Tpetra::Map<MultiVecAdapter<Epetra_MultiVector>::local_ordinal_t, MultiVecAdapter<Epetra_MultiVector>::global_ordinal_t, MultiVecAdapter<Epetra_MultiVector>::node_t> > source_map) { using Teuchos::rcpFromPtr; using Teuchos::as; const size_t num_vecs = getGlobalNumVectors(); // TODO: check that the following const_cast is safe double* data_ptr = const_cast<double*>(new_data.getRawPtr()); // Optimization for ROOTED // TODO: Element-wise copy rather than using importer if ( num_vecs == 1 && mv_->Comm().MyPID() == 0 && mv_->Comm().NumProc() == 1 ) { const multivec_t source_mv(Copy, *mv_map_, data_ptr, as<int>(lda), as<int>(num_vecs)); const Epetra_Import importer(*mv_map_, *mv_map_); //trivial - map does not change mv_->Import(source_mv, importer, Insert); } else { const Epetra_BlockMap e_source_map = *Util::tpetra_map_to_epetra_map<local_ordinal_t,global_ordinal_t,global_size_t,node_t>(*source_map); const multivec_t source_mv(Copy, e_source_map, data_ptr, as<int>(lda), as<int>(num_vecs)); const Epetra_Import importer(*mv_map_, e_source_map); mv_->Import(source_mv, importer, Insert); } }
//---------------------------------------------------------------------------// // Map a point to the reference space of an entity. Return the parameterized // point. bool MoabEntityLocalMap::mapToReferenceFrame( const Entity& entity, const Teuchos::ArrayView<const double>& physical_point, const Teuchos::ArrayView<double>& reference_point ) const { cacheEntity( entity ); int is_inside = -1; // Ignore the error code on this one because of the ridiculous // tolerancing/convergence scheme used in the implementation. d_moab_evaluator->reverse_eval( physical_point.getRawPtr(), d_newton_tol, d_inclusion_tol, reference_point.getRawPtr(), &is_inside ); return (is_inside > 0); }
void MultiVecAdapter<Epetra_MultiVector>::get1dCopy( const Teuchos::ArrayView<MultiVecAdapter<Epetra_MultiVector>::scalar_t>& av, size_t lda, Teuchos::Ptr< const Tpetra::Map<MultiVecAdapter<Epetra_MultiVector>::local_ordinal_t, MultiVecAdapter<Epetra_MultiVector>::global_ordinal_t, MultiVecAdapter<Epetra_MultiVector>::node_t> > distribution_map ) const { using Teuchos::rcpFromPtr; using Teuchos::as; const size_t num_vecs = getGlobalNumVectors(); #ifdef HAVE_AMESOS2_DEBUG const size_t requested_vector_length = distribution_map->getNodeNumElements(); TEUCHOS_TEST_FOR_EXCEPTION( lda < requested_vector_length, std::invalid_argument, "Given stride is not large enough for local vector length" ); TEUCHOS_TEST_FOR_EXCEPTION( as<size_t>(av.size()) < (num_vecs-1) * lda + requested_vector_length, std::invalid_argument, "MultiVector storage not large enough given leading dimension " "and number of vectors" ); #endif // Optimization for ROOTED if ( num_vecs == 1 && mv_->Comm().MyPID() == 0 && mv_->Comm().NumProc() == 1 ) { mv_->ExtractCopy(av.getRawPtr(), lda); } else { Epetra_Map e_dist_map = *Util::tpetra_map_to_epetra_map<local_ordinal_t, global_ordinal_t, global_size_t, node_t>(*distribution_map); multivec_t redist_mv(e_dist_map, as<int>(num_vecs)); const Epetra_Import importer(e_dist_map, *mv_map_); // Note, target/source order is reversed in Tpetra redist_mv.Import(*mv_, importer, Insert); // Finally, do copy redist_mv.ExtractCopy(av.getRawPtr(), lda); } }
void RTOpC::extract_reduct_obj_state_impl( const ReductTarget &reduct_obj, const Teuchos::ArrayView<primitive_value_type> &value_data, const Teuchos::ArrayView<index_type> &index_data, const Teuchos::ArrayView<char_type> &char_data ) const { TEUCHOS_TEST_FOR_EXCEPTION( 0!=RTOp_extract_reduct_obj_state( &op_, (*this)(reduct_obj), value_data.size(), value_data.getRawPtr(), index_data.size(), index_data.getRawPtr(), char_data.size(), char_data.getRawPtr() ), UnknownError, "RTOpC::extract_reduct_obj_state(...): Error, " "RTOp_extract_reduct_obj_state(...) returned != 0" ); }
//---------------------------------------------------------------------------// // Determine if a reference point is in the parameterized space of an entity. bool MoabEntityLocalMap::checkPointInclusion( const Entity& entity, const Teuchos::ArrayView<const double>& reference_point ) const { cacheEntity( entity ); int is_inside = d_moab_evaluator->inside( reference_point.getRawPtr(), d_inclusion_tol ); return (is_inside > 0); }
void RTOpC::load_reduct_obj_state_impl( const Teuchos::ArrayView<const primitive_value_type> &value_data, const Teuchos::ArrayView<const index_type> &index_data, const Teuchos::ArrayView<const char_type> &char_data, const Teuchos::Ptr<ReductTarget> &reduct_obj ) const { TEUCHOS_TEST_FOR_EXCEPTION( 0!=RTOp_load_reduct_obj_state( &op_, value_data.size(), value_data.getRawPtr(), index_data.size(), index_data.getRawPtr(), char_data.size(), char_data.getRawPtr(), (*this)(*reduct_obj) ), UnknownError, "RTOpC::load_reduct_obj_state(...): Error, " "RTOp_load_reduct_obj_state(...) returned != 0" ); }
//---------------------------------------------------------------------------// // Return the centroid of the entity. void MoabEntityLocalMap::centroid( const Entity& entity, const Teuchos::ArrayView<double>& centroid ) const { // Node case. if ( 0 == entity.topologicalDimension() ) { moab::EntityHandle handle = MoabHelpers::extractEntity(entity); d_moab_mesh->get_moab()->get_coords( &handle, 1, centroid.getRawPtr() ); } // Element case. else { cacheEntity( entity ); Teuchos::Array<double> param_center; parametricCenter( entity, param_center ); DTK_CHECK_ERROR_CODE( d_moab_evaluator->eval( param_center.getRawPtr(), centroid.getRawPtr() ) ); } }
Kokkos::View<const T*,D> getKokkosViewDeepCopy(const Teuchos::ArrayView<const T>& a) { #if defined(KOKKOS_HAVE_PTHREAD) typedef Kokkos::Threads HostDevice; #elif defined(KOKKOS_HAVE_OPENMP) typedef Kokkos::OpenMP HostDevice; #else typedef Kokkos::Serial HostDevice; #endif typedef Kokkos::View<T*,D> view_type; typedef Kokkos::View<const T*,typename view_type::array_layout,HostDevice,Kokkos::MemoryUnmanaged> unmanaged_host_view_type; if (a.size() == 0) return view_type(); view_type v("", a.size()); unmanaged_host_view_type hv(a.getRawPtr(), a.size()); Kokkos::deep_copy(v,hv); return v; }
Kokkos::View<const T*,D> getKokkosViewDeepCopy(const Teuchos::ArrayView<const T>& a) { typedef typename Kokkos::Impl::if_c< Impl::VerifyExecutionCanAccessMemorySpace< D, Kokkos::HostSpace>::value, typename D::execution_space, Kokkos::HostSpace>::type HostDevice; typedef Kokkos::View<T*, D> view_type; typedef Kokkos::View<const T*, typename view_type::array_layout, HostDevice, Kokkos::MemoryUnmanaged> unmanaged_host_view_type; if (a.size () == 0) { return view_type (); } view_type v ("", a.size ()); unmanaged_host_view_type hv (a.getRawPtr (), a.size ()); Kokkos::deep_copy (v, hv); return v; }
Map<LocalOrdinal,GlobalOrdinal,Kokkos::Compat::KokkosDeviceWrapperNode<DeviceType> >:: Map (const global_size_t globalNumIndices, const Teuchos::ArrayView<const GlobalOrdinal>& myGlobalIndices, const GlobalOrdinal indexBase, const Teuchos::RCP<const Teuchos::Comm<int> >& comm, const Teuchos::RCP<node_type> &node) : comm_ (comm), node_ (node), directory_ (new Directory<LocalOrdinal, GlobalOrdinal, node_type> ()) { typedef GlobalOrdinal GO; typedef Kokkos::View<const GlobalOrdinal*, device_type, Kokkos::MemoryUnmanaged> host_view_type; typedef Kokkos::View<GlobalOrdinal*, device_type> device_view_type; // Copy the input GID list from host (we assume that // Teuchos::ArrayView should only view host memory) to device. // // FIXME (mfh 06 Feb, 24 Mar 2014) We could use the CUDA API // function here that can look at a pointer and tell whether it // lives on host or device, to tell whether the Teuchos::ArrayView // is viewing host or device memory. Regardless, we don't own the // data and we will need a deep copy anyway, so we might as well // copy it. host_view_type gidsHost (myGlobalIndices.getRawPtr (), myGlobalIndices.size ()); device_view_type gidsDevice ("GIDs", myGlobalIndices.size ()); Kokkos::deep_copy (gidsDevice, gidsHost); const global_size_t GSTI = Teuchos::OrdinalTraits<global_size_t>::invalid (); const GO globalNumInds = (globalNumIndices == GSTI) ? getInvalidGlobalIndex () : Teuchos::as<GO> (globalNumIndices); // Start with a host Map implementation, since this will make this // class' public (host) methods work. If users want device // methods, they will call getDeviceView(), which will initialize // the device Map implementation. // // NOTE (mfh 06 Feb 2014) If we're using UVM, we don't really need // the host and device Maps to be separate. mapHost_ = host_impl_type (globalNumInds, gidsDevice, indexBase, *comm); // Create the Directory on demand in getRemoteIndexList(). }
void MultiVecAdapter<Epetra_MultiVector>::put1dData( const Teuchos::ArrayView<const MultiVecAdapter<Epetra_MultiVector>::scalar_t>& new_data, size_t lda, Teuchos::Ptr< const Tpetra::Map<MultiVecAdapter<Epetra_MultiVector>::local_ordinal_t, MultiVecAdapter<Epetra_MultiVector>::global_ordinal_t, MultiVecAdapter<Epetra_MultiVector>::node_t> > source_map) { using Teuchos::rcpFromPtr; using Teuchos::as; const size_t num_vecs = getGlobalNumVectors(); // TODO: check that the following const_cast is safe double* data_ptr = const_cast<double*>(new_data.getRawPtr()); const Epetra_BlockMap e_source_map = *Util::tpetra_map_to_epetra_map<local_ordinal_t,global_ordinal_t,global_size_t,node_t>(*source_map); const multivec_t source_mv(Copy, e_source_map, data_ptr, as<int>(lda), as<int>(num_vecs)); const Epetra_Import importer(*mv_map_, e_source_map); mv_->Import(source_mv, importer, Insert); }
PyObject * convertToDimData(const Teuchos::RCP< const Tpetra::Map< PYTRILINOS_LOCAL_ORD, PYTRILINOS_GLOBAL_ORD > > & tm, int extraDim) { // Initialization PyObject * dim_data = NULL; PyObject * dim_dict = NULL; PyObject * indices = NULL; npy_intp dims = 1; int currentDim = 0; Teuchos::ArrayView< const PYTRILINOS_GLOBAL_ORD > nodeBlockIDs; // Get the Teuchos::Comm Teuchos::RCP< const Teuchos::Comm< int > > comm = tm->getComm(); // Get the number of dimensions. The vector data constitutes one // dimension. If the extraDim is greater than one, then that // constitutes a second possible dimension. Py_ssize_t ndim = 1; if (extraDim > 1) ndim += 1; // Allocate the dim_data return object, which is a tuple of length // ndim dim_data = PyTuple_New(ndim); if (!dim_data) goto fail; // If we have an extra dimension argument greater than one, then // define a dimension associated with the multiple vectors if (extraDim > 1) { dim_dict = PyDict_New(); if (!dim_dict) goto fail; if (PyDict_SetItemString(dim_dict, "dist_type", PyString_FromString("n")) == -1) goto fail; if (PyDict_SetItemString(dim_dict, "size", PyInt_FromLong(extraDim)) == -1) goto fail; // This function steals a reference from dim_dict PyTuple_SET_ITEM(dim_data, currentDim, dim_dict); currentDim += 1; } // Allocate the dimension data dictionary for the distributed points // and assign the common key values dim_dict = PyDict_New(); if (!dim_dict) goto fail; if (PyDict_SetItemString(dim_dict, "size", PyInt_FromLong(tm->getGlobalNumElements())) == -1) goto fail; if (PyDict_SetItemString(dim_dict, "proc_grid_size", PyInt_FromLong(comm->getSize())) == -1) goto fail; if (PyDict_SetItemString(dim_dict, "proc_grid_rank", PyInt_FromLong(comm->getRank())) == -1) goto fail; // Determine the type of the dimension data, either block "b" or // unstructured "u", set the "dist_type" key and other keys required // according to dist_type. if (tm->isContiguous()) { // isContiguous() == true corresponds to DistArray Protocol // dist_type == "b" (block) if (PyDict_SetItemString(dim_dict, "dist_type", PyString_FromString("b")) == -1) goto fail; if (PyDict_SetItemString(dim_dict, "start", PyInt_FromLong(tm->getMinGlobalIndex())) == -1) goto fail; if (PyDict_SetItemString(dim_dict, "stop", PyInt_FromLong(tm->getMaxGlobalIndex()+1)) == -1) goto fail; } else { // isContiguous() == false corresponds to DistArray Protocol // dist_type == "u" (unstructured) if (PyDict_SetItemString(dim_dict, "dist_type", PyString_FromString("u")) == -1) goto fail; dims = tm->getNodeElementList().size(); nodeBlockIDs = tm->getNodeElementList(); indices = PyArray_SimpleNewFromData(1, &dims, NPY_LONG, (void*)nodeBlockIDs.getRawPtr()); if (!indices) goto fail; if (PyDict_SetItemString(dim_dict, "indices", indices) == -1) goto fail; Py_DECREF(indices); indices = NULL; } // Put the dimension dictionary into the dim_data tuple PyTuple_SET_ITEM(dim_data, currentDim, dim_dict); // Return the dim_data tuple return dim_data; // Error handling fail: Py_XDECREF(dim_data); Py_XDECREF(dim_dict); Py_XDECREF(indices); return NULL; }
LookupStatus EpetraMap::getRemoteIndexList(const Teuchos::ArrayView< const int > &GIDList, const Teuchos::ArrayView< int > &nodeIDList) const { XPETRA_MONITOR("EpetraMap::getRemoteIndexList"); return toXpetra(map_->RemoteIDList(GIDList.size(), GIDList.getRawPtr(), nodeIDList.getRawPtr(), 0)); }
// TODO: UnitTest FAILED EpetraMap::EpetraMap(global_size_t numGlobalElements, const Teuchos::ArrayView<const int> &elementList, int indexBase, const Teuchos::RCP<const Teuchos::Comm<int> > &comm, const Teuchos::RCP<Node> &node) { if (numGlobalElements == Teuchos::OrdinalTraits<global_size_t>::invalid()) { IF_EPETRA_EXCEPTION_THEN_THROW_GLOBAL_INVALID_ARG((map_ = (rcp(new Epetra_BlockMap(-1, elementList.size(), elementList.getRawPtr(), 1, indexBase, *toEpetra(comm)))))); } else { IF_EPETRA_EXCEPTION_THEN_THROW_GLOBAL_INVALID_ARG((map_ = (rcp(new Epetra_BlockMap(numGlobalElements, elementList.size(), elementList.getRawPtr(), 1, indexBase, *toEpetra(comm)))))); } }
void EpetraMultiVector::normInf(const Teuchos::ArrayView< Teuchos::ScalarTraits< Scalar >::magnitudeType > &norms) const { XPETRA_MONITOR("EpetraMultiVector::normInf"); vec_->NormInf(norms.getRawPtr()); }
void EpetraMultiVector::normWeighted(const MultiVector<double,int,int> &weights, const Teuchos::ArrayView<Teuchos::ScalarTraits<double>::magnitudeType> &norms) const { XPETRA_MONITOR("EpetraMultiVector::normWeighted"); XPETRA_DYNAMIC_CAST(const EpetraMultiVector, weights, eWeights, "This Xpetra::EpetraMultiVector method only accept Xpetra::EpetraMultiVector as input arguments."); vec_->NormWeighted(*eWeights.getEpetra_MultiVector(), norms.getRawPtr()); }
void EpetraMultiVector::meanValue(const Teuchos::ArrayView<double> &means) const { XPETRA_MONITOR("EpetraMultiVector::meanValue"); vec_->MeanValue(means.getRawPtr()); } //TODO: modify ArrayView size ??
void EpetraMultiVector::dot(const MultiVector<double,int,int> &A, const Teuchos::ArrayView<double> &dots) const { XPETRA_MONITOR("EpetraMultiVector::dot"); XPETRA_DYNAMIC_CAST(const EpetraMultiVector, A, eA, "This Xpetra::EpetraMultiVector method only accept Xpetra::EpetraMultiVector as input arguments."); vec_->Dot(*eA.getEpetra_MultiVector(), dots.getRawPtr()); }