Teuchos::Array<EpetraGlobalIndex> getMyLIDs(
const Epetra_BlockMap &map,
const Teuchos::ArrayView<const EpetraGlobalIndex> &selectedGIDs)
{
Teuchos::Array<EpetraGlobalIndex> sortedMyGIDs(map.MyGlobalElements(), map.MyGlobalElements() + map.NumMyElements());
std::sort(sortedMyGIDs.begin(), sortedMyGIDs.end());
Teuchos::Array<EpetraGlobalIndex> sortedSelectedGIDs(selectedGIDs);
std::sort(sortedSelectedGIDs.begin(), sortedSelectedGIDs.end());
Teuchos::Array<EpetraGlobalIndex> mySelectedGIDs;
std::set_intersection(sortedMyGIDs.begin(), sortedMyGIDs.end(),
sortedSelectedGIDs.begin(), sortedSelectedGIDs.end(),
std::back_inserter(mySelectedGIDs));
Teuchos::Array<EpetraGlobalIndex> result;
result.reserve(mySelectedGIDs.size());
std::transform(
mySelectedGIDs.begin(), mySelectedGIDs.end(),
std::back_inserter(result),
std::bind1st(std::mem_fun_ref(static_cast<int(Epetra_BlockMap::*)(EpetraGlobalIndex) const>(&Epetra_BlockMap::LID)), map));
return result;
}
// Epetra_Export constructor for a Epetra_BlockMap object
Epetra_Export::Epetra_Export( const Epetra_BlockMap & sourceMap, const Epetra_BlockMap & targetMap)
: Epetra_Object("Epetra::Export"),
TargetMap_(targetMap),
SourceMap_(sourceMap),
NumSameIDs_(0),
NumPermuteIDs_(0),
PermuteToLIDs_(0),
PermuteFromLIDs_(0),
NumRemoteIDs_(0),
RemoteLIDs_(0),
NumExportIDs_(0),
ExportLIDs_(0),
ExportPIDs_(0),
NumSend_(0),
NumRecv_(0),
Distor_(0)
{
if(!targetMap.GlobalIndicesTypeMatch(sourceMap))
throw ReportError("Epetra_Export::Epetra_Export: GlobalIndicesTypeMatch failed", -1);
if(targetMap.GlobalIndicesInt())
#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
Construct<int>(sourceMap, targetMap);
#else
throw ReportError("Epetra_Export::Epetra_Export: ERROR, GlobalIndicesInt but no API for it.",-1);
#endif
else if(targetMap.GlobalIndicesLongLong())
Teuchos::Array<int>
Albany::NodeGIDsSolutionCullingStrategy::
selectedGIDs(const Epetra_BlockMap &sourceMap) const
{
Teuchos::Array<int> result;
{
Teuchos::Array<int> mySelectedGIDs;
// Subract 1 to convert exodus GIDs to our GIDs
for (int i=0; i<nodeGIDs_.size(); i++)
if (sourceMap.MyGID(nodeGIDs_[i] -1) ) mySelectedGIDs.push_back(nodeGIDs_[i] - 1);
const Epetra_Comm &comm = sourceMap.Comm();
{
int selectedGIDCount;
{
int mySelectedGIDCount = mySelectedGIDs.size();
comm.SumAll(&mySelectedGIDCount, &selectedGIDCount, 1);
}
result.resize(selectedGIDCount);
}
const int ierr = Epetra::GatherAllV(
comm,
mySelectedGIDs.getRawPtr(), mySelectedGIDs.size(),
result.getRawPtr(), result.size());
TEUCHOS_ASSERT(ierr == 0);
}
std::sort(result.begin(), result.end());
return result;
}
MapEpetra::MapEpetra ( const Epetra_BlockMap& blockMap, const Int offset, const Int maxId) :
M_commPtr(blockMap.Comm().Clone())
{
std::vector<Int> myGlobalElements;
Int* sourceGlobalElements ( blockMap.MyGlobalElements() );
Int const startIdOrig ( offset );
Int const endIdOrig ( startIdOrig + maxId );
const Int maxMyElements = std::min ( maxId, blockMap.NumMyElements() );
myGlobalElements.reserve ( maxMyElements );
//Sort MyGlobalElements to avoid a bug in Trilinos (9?) when multiplying two matrices (A * B^T)
std::sort ( myGlobalElements.begin(), myGlobalElements.end() );
// We consider that the source Map may not be ordered
for ( Int i (0); i < blockMap.NumMyElements(); ++i )
if ( sourceGlobalElements[i] < endIdOrig && sourceGlobalElements[i] >= startIdOrig )
{
myGlobalElements.push_back ( sourceGlobalElements[i] - offset );
}
createMap ( -1,
myGlobalElements.size(),
&myGlobalElements.front(),
*M_commPtr );
}
Teuchos::RCP<Epetra_Map> mapDowncast(const Epetra_BlockMap &in)
{
if (in.ConstantElementSize() && in.ElementSize() == 1) {
return Teuchos::rcp(new Epetra_Map(static_cast<const Epetra_Map &>(in)));
}
return Teuchos::null;
}
void EpetraCrsGraph::describe(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel) const {
XPETRA_MONITOR("EpetraCrsGraph::describe");
out << "EpetraCrsGraph::describe : Warning, verbosity level is ignored by this method." << std::endl;
const Epetra_BlockMap rowmap = graph_->RowMap();
if (rowmap.Comm().MyPID() == 0) out << "** EpetraCrsGraph **\n\nrowmap" << std::endl;
rowmap.Print(out);
graph_->Print(out);
}
VectorEpetra<T>::VectorEpetra ( Epetra_BlockMap const& emap )
:
super( emap.NumGlobalElements(), emap.NumMyElements() ),
M_emap( emap ),
M_vec( M_emap )
//M_destroy_vec_on_exit( true )
{
this->init( M_emap, true );
checkInvariants();
}
ArrayRCP<zgno_t> roundRobinMap(const Epetra_BlockMap &emap)
{
const Epetra_Comm &comm = emap.Comm();
int proc = comm.MyPID();
int nprocs = comm.NumProc();
zgno_t basegid = emap.MinAllGID();
zgno_t maxgid = emap.MaxAllGID();
size_t nglobalrows = emap.NumGlobalElements();
return roundRobinMapShared(proc, nprocs, basegid, maxgid, nglobalrows);
}
int BlockMapToHandle(FILE * handle, const Epetra_BlockMap & map) {
#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
if(map.GlobalIndicesInt()) {
return TBlockMapToHandle<int>(handle, map);
}
else
#endif
#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
if(map.GlobalIndicesLongLong()) {
return TBlockMapToHandle<long long>(handle, map);
}
else
#endif
throw "EpetraExt::BlockMapToHandle: GlobalIndices type unknown";
}
//EpetraMap_To_TpetraMap: takes in Epetra_Map object, converts it to its equivalent Tpetra::Map object,
//and returns an RCP pointer to this Tpetra::Map
Teuchos::RCP<const Tpetra_Map> Petra::EpetraMap_To_TpetraMap(const Epetra_BlockMap& epetraMap_,
const Teuchos::RCP<const Teuchos::Comm<int> >& commT_)
{
const std::size_t numElements = Teuchos::as<std::size_t>(epetraMap_.NumMyElements());
const auto indexBase = Teuchos::as<GO>(epetraMap_.IndexBase());
if (epetraMap_.DistributedGlobal() || epetraMap_.Comm().NumProc() == Teuchos::OrdinalTraits<int>::one()) {
Teuchos::Array<Tpetra_GO> indices(numElements);
int *epetra_indices = epetraMap_.MyGlobalElements();
for(LO i=0; i < numElements; i++)
indices[i] = epetra_indices[i];
const Tpetra::global_size_t computeGlobalElements = Teuchos::OrdinalTraits<Tpetra::global_size_t>::invalid();
return Teuchos::rcp(new Tpetra_Map(computeGlobalElements, indices, indexBase, commT_));
} else {
return Teuchos::rcp(new Tpetra_Map(numElements, indexBase, commT_, Tpetra::LocallyReplicated));
}
}
int BlockUtility::CalculateOffset(const Epetra_BlockMap & BaseMap)
{
if(BaseMap.GlobalIndicesInt())
return TCalculateOffset<int>(BaseMap);
else
throw "EpetraExt::BlockUtility::GenerateBlockMap: Global Indices not int.";
}
Teuchos::Array<int>
Albany::NodeSetSolutionCullingStrategy::
selectedGIDs(const Epetra_BlockMap &sourceMap) const
{
Teuchos::Array<int> result;
{
Teuchos::Array<int> mySelectedGIDs;
{
const NodeSetList &nodeSets = disc_->getNodeSets();
const NodeSetList::const_iterator it = nodeSets.find(nodeSetLabel_);
if (it != nodeSets.end()) {
typedef NodeSetList::mapped_type NodeSetEntryList;
const NodeSetEntryList &sampleNodeEntries = it->second;
for (NodeSetEntryList::const_iterator jt = sampleNodeEntries.begin(); jt != sampleNodeEntries.end(); ++jt) {
typedef NodeSetEntryList::value_type NodeEntryList;
const NodeEntryList &sampleEntries = *jt;
for (NodeEntryList::const_iterator kt = sampleEntries.begin(); kt != sampleEntries.end(); ++kt) {
mySelectedGIDs.push_back(sourceMap.GID(*kt));
}
}
}
}
const Epetra_Comm &comm = sourceMap.Comm();
{
int selectedGIDCount;
{
int mySelectedGIDCount = mySelectedGIDs.size();
comm.SumAll(&mySelectedGIDCount, &selectedGIDCount, 1);
}
result.resize(selectedGIDCount);
}
const int ierr = Epetra::GatherAllV(
comm,
mySelectedGIDs.getRawPtr(), mySelectedGIDs.size(),
result.getRawPtr(), result.size());
TEUCHOS_ASSERT(ierr == 0);
}
std::sort(result.begin(), result.end());
return result;
}
int
LOCA::Epetra::AugmentedOp::blockMap2PointMap(const Epetra_BlockMap& BlockMap,
Epetra_Map*& PointMap) const
{
// Generate an Epetra_Map that has the same number and distribution of points
// as the input Epetra_BlockMap object. The global IDs for the output PointMap
// are computed by using the MaxElementSize of the BlockMap. For variable block
// sizes this will create gaps in the GID space, but that is OK for Epetra_Maps.
int MaxElementSize = BlockMap.MaxElementSize();
int PtNumMyElements = BlockMap.NumMyPoints();
int * PtMyGlobalElements = 0;
if (PtNumMyElements>0) PtMyGlobalElements = new int[PtNumMyElements];
int NumMyElements = BlockMap.NumMyElements();
int curID = 0;
for (int i=0; i<NumMyElements; i++) {
int StartID = BlockMap.GID(i)*MaxElementSize;
int ElementSize = BlockMap.ElementSize(i);
for (int j=0; j<ElementSize; j++) PtMyGlobalElements[curID++] = StartID+j;
}
assert(curID==PtNumMyElements); // Sanity test
PointMap = new Epetra_Map(-1, PtNumMyElements, PtMyGlobalElements, BlockMap.IndexBase(), BlockMap.Comm());
if (PtNumMyElements>0) delete [] PtMyGlobalElements;
if (!BlockMap.PointSameAs(*PointMap)) {EPETRA_CHK_ERR(-1);} // Maps not compatible
return(0);
}
//==============================================================================
Epetra_BlockMap::Epetra_BlockMap(const Epetra_BlockMap& map)
: Epetra_Object(map.Label()),
BlockMapData_(map.BlockMapData_)
{
BlockMapData_->IncrementReferenceCount();
// This call appears to be unnecessary overhead. Removed 10-Aug-2004 maherou.
// GlobalToLocalSetup(); // Setup any information for making global index to local index translation fast.
}
int_type BlockUtility::TCalculateOffset(const Epetra_BlockMap & BaseMap)
{
int_type MaxGID = (int_type) BaseMap.MaxAllGID64();
// int Offset = 1;
// while( Offset <= MaxGID ) Offset *= 10;
// return Offset;
return MaxGID+1;
}
Epetra_DistObject::Epetra_DistObject(const Epetra_BlockMap& map)
: Epetra_Object("Epetra::DistObject"),
Map_(map),
Comm_(&Map_.Comm()),
DistributedGlobal_(map.DistributedGlobal()),
Exports_(0),
Imports_(0),
LenExports_(0),
LenImports_(0),
Sizes_(0)
{}
Epetra_DistObject::Epetra_DistObject(const Epetra_BlockMap& map, const char* const label)
: Epetra_Object(label),
Map_(map),
Comm_(&Map_.Comm()),
DistributedGlobal_(map.DistributedGlobal()),
Exports_(0),
Imports_(0),
LenExports_(0),
LenImports_(0),
Sizes_(0)
{}
Teuchos::Array<int>
Albany::UniformSolutionCullingStrategy::
selectedGIDs(const Epetra_BlockMap &sourceMap) const
{
Teuchos::Array<int> allGIDs(sourceMap.NumGlobalElements());
{
const int ierr = Epetra::GatherAllV(
sourceMap.Comm(),
sourceMap.MyGlobalElements(), sourceMap.NumMyElements(),
allGIDs.getRawPtr(), allGIDs.size());
TEUCHOS_ASSERT(ierr == 0);
}
std::sort(allGIDs.begin(), allGIDs.end());
Teuchos::Array<int> result(numValues_);
const int stride = 1 + (allGIDs.size() - 1) / numValues_;
for (int i = 0; i < numValues_; ++i) {
result[i] = allGIDs[i * stride];
}
return result;
}
//=============================================================================
Epetra_LongLongVector::Epetra_LongLongVector(const Epetra_BlockMap& map, bool zeroOut)
: Epetra_DistObject(map, "Epetra::LongLongVector"),
Values_(0),
UserAllocated_(false),
Allocated_(false)
{
if(!map.GlobalIndicesLongLong())
throw ReportError("Epetra_LongLongVector::Epetra_LongLongVector: cannot be called with non long long map index type", -1);
AllocateForCopy();
if(zeroOut) PutValue(0); // Zero out values
}
// =============================================================================
Epetra_NumPyMultiVector::Epetra_NumPyMultiVector(const Epetra_BlockMap & blockMap,
PyObject * pyObject):
Epetra_MultiVector(View, blockMap, getArray(blockMap,pyObject),
blockMap.NumMyPoints(), getNumVectors(blockMap,pyObject))
{
// Store the array pointer
array = tmp_array;
tmp_array = NULL;
// Copy the Epetra_BlockMap
map = new Epetra_BlockMap(blockMap);
}
//=========================================================================
int Ifpack_CrsRiluk::BlockMap2PointMap(const Epetra_BlockMap & BlockMap, Teuchos::RefCountPtr<Epetra_Map>* PointMap) {
// Generate an Epetra_Map that has the same number and distribution of points
// as the input Epetra_BlockMap object. The global IDs for the output PointMap
// are computed by using the MaxElementSize of the BlockMap. For variable block
// sizes this will create gaps in the GID space, but that is OK for Epetra_Maps.
int MaxElementSize = BlockMap.MaxElementSize();
int PtNumMyElements = BlockMap.NumMyPoints();
vector<int> PtMyGlobalElements;
if (PtNumMyElements>0) PtMyGlobalElements.resize(PtNumMyElements);
int NumMyElements = BlockMap.NumMyElements();
int curID = 0;
for (int i=0; i<NumMyElements; i++) {
int StartID = BlockMap.GID(i)*MaxElementSize;
int ElementSize = BlockMap.ElementSize(i);
for (int j=0; j<ElementSize; j++) PtMyGlobalElements[curID++] = StartID+j;
}
assert(curID==PtNumMyElements); // Sanity test
(*PointMap) = Teuchos::rcp( new Epetra_Map(-1, PtNumMyElements, &PtMyGlobalElements[0], BlockMap.IndexBase(), BlockMap.Comm()) );
if (!BlockMap.PointSameAs(*(*PointMap))) {EPETRA_CHK_ERR(-1);} // Maps not compatible
return(0);
}
//----------------------------------------------------------------------------
Epetra_FEVector::Epetra_FEVector(Epetra_DataAccess CV, const Epetra_BlockMap& Map,
double *A, int MyLDA, int NumVectors,
bool ignoreNonLocalEntries)
: Epetra_MultiVector(CV, Map, A, MyLDA, NumVectors),
myFirstID_(0),
myNumIDs_(0),
#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
nonlocalIDs_int_(),
#endif
#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
nonlocalIDs_LL_(),
#endif
nonlocalElementSize_(),
nonlocalCoefs_(),
nonlocalMap_(0),
exporter_(0),
nonlocalVector_(0),
ignoreNonLocalEntries_(ignoreNonLocalEntries)
{
myFirstID_ = Map.MinMyGID64();
myNumIDs_ = Map.NumMyElements();
nonlocalCoefs_.resize(NumVectors);
}
//----------------------------------------------------------------------------
Epetra_FEVector::Epetra_FEVector(const Epetra_BlockMap& map,
int numVectors,
bool ignoreNonLocalEntries)
: Epetra_MultiVector(map, numVectors),
myFirstID_(0),
myNumIDs_(0),
#ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
nonlocalIDs_int_(),
#endif
#ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
nonlocalIDs_LL_(),
#endif
nonlocalElementSize_(),
nonlocalCoefs_(),
nonlocalMap_(0),
exporter_(0),
nonlocalVector_(0),
ignoreNonLocalEntries_(ignoreNonLocalEntries)
{
myFirstID_ = map.MinMyGID64();
myNumIDs_ = map.NumMyElements();
nonlocalCoefs_.resize(numVectors);
}
//==============================================================================
bool Epetra_BlockMap::PointSameAs(const Epetra_BlockMap & Map) const
{
if (this->BlockMapData_ == Map.BlockMapData_)
return(true);
if(!GlobalIndicesTypeMatch(Map))
return(false);
if (BlockMapData_->NumGlobalPoints_ != Map.NumGlobalPoints64() )
return(false);
// If we get this far, we need to check local properties and then check across
// all processors to see if local properties are all true
int MySameMap = 1; // Assume not needed
if (BlockMapData_->NumMyPoints_ != Map.NumMyPoints())
MySameMap = 0;
int GlobalSameMap = 0;
int err = Comm().MinAll(&MySameMap, &GlobalSameMap, 1);
assert( err == 0 );
return(GlobalSameMap==1);
}
// FIXME long long
Epetra_BlockMap
Epetra_Util::Create_OneToOne_BlockMap(const Epetra_BlockMap& usermap,
bool high_rank_proc_owns_shared)
{
// FIXME long long
//if usermap is already 1-to-1 then we'll just return a copy of it.
if (usermap.IsOneToOne()) {
Epetra_BlockMap newmap(usermap);
return(newmap);
}
int myPID = usermap.Comm().MyPID();
Epetra_Directory* directory = usermap.Comm().CreateDirectory(usermap);
int numMyElems = usermap.NumMyElements();
const int* myElems = usermap.MyGlobalElements();
int* owner_procs = new int[numMyElems*2];
int* sizes = owner_procs+numMyElems;
directory->GetDirectoryEntries(usermap, numMyElems, myElems, owner_procs,
0, sizes, high_rank_proc_owns_shared);
//we'll fill a list of map-elements which belong on this processor
int* myOwnedElems = new int[numMyElems*2];
int* ownedSizes = myOwnedElems+numMyElems;
int numMyOwnedElems = 0;
for(int i=0; i<numMyElems; ++i) {
int GID = myElems[i];
int owner = owner_procs[i];
if (myPID == owner) {
ownedSizes[numMyOwnedElems] = sizes[i];
myOwnedElems[numMyOwnedElems++] = GID;
}
}
Epetra_BlockMap one_to_one_map(-1, numMyOwnedElems, myOwnedElems,
sizes, usermap.IndexBase(), usermap.Comm());
delete [] myOwnedElems;
delete [] owner_procs;
delete directory;
return(one_to_one_map);
}
// Constructors
// =============================================================================
Epetra_NumPyMultiVector::Epetra_NumPyMultiVector(const Epetra_BlockMap & blockMap,
int numVectors, bool zeroOut):
Epetra_MultiVector(blockMap, numVectors, zeroOut)
{
// Create the array object
npy_intp dims[ ] = { numVectors, blockMap.NumMyPoints() };
double **v = NULL;
Epetra_MultiVector::ExtractView(&v);
array = (PyArrayObject *) PyArray_SimpleNewFromData(2,dims,NPY_DOUBLE,
(void *)v[0]);
if (!array)
{
cleanup();
throw PythonException();
}
// Copy the Epetra_BlockMap
map = new Epetra_BlockMap(blockMap);
}
// Constructors
// =============================================================================
Epetra_NumPyIntVector::Epetra_NumPyIntVector(const Epetra_BlockMap & blockMap,
bool zeroOut):
Epetra_IntVector(blockMap, zeroOut)
{
// Create the array object
npy_intp dims[ ] = { blockMap.NumMyPoints() };
int *v = NULL;
Epetra_IntVector::ExtractView(&v);
array = (PyArrayObject *)
PyArray_SimpleNewFromData(1,dims,NPY_INT,(void *)v);
if (!array)
{
cleanup();
throw PythonException();
}
// Copy the Epetra_BlockMap
map = new Epetra_BlockMap(blockMap);
}
//=============================================================================
Epetra_LongLongVector::Epetra_LongLongVector(Epetra_DataAccess CV, const Epetra_BlockMap& map, long long *V)
: Epetra_DistObject(map, "Epetra::LongLongVector"),
Values_(0),
UserAllocated_(false),
Allocated_(false)
{
if(!map.GlobalIndicesLongLong())
throw ReportError("Epetra_LongLongVector::Epetra_LongLongVector: cannot be called with non long long map index type", -1);
if (CV==Copy) {
AllocateForCopy();
DoCopy(V);
}
else {
AllocateForView();
DoView(V);
}
}
// ============================================================================
std::shared_ptr<const Tpetra::Map<int,int>>
BorderingHelpers::
extendMapBy1(const Epetra_BlockMap & map)
{
const Teuchos::Comm<int> & comm = map.Comm();
// Create a new map that hosts one more entry.
const int numGlobalElements = map.NumGlobalElements() + 1;
const int numMyElements = map.NumMyElements();
int * myGlobalElements = map.MyGlobalElements();
// The following if-else construction just makes sure that
// the Tpetra::Map<int,int> constructor is called with an extended
// map on proc 0, and with the regular old stuff on all
// other procs.
std::shared_ptr<Tpetra::Map<int,int>> extendedMap;
if (comm.MyPID() == 0) {
// Copy over the global indices.
std::vector<int> a(numMyElements+1);
for (int k = 0; k < numMyElements; k++)
a[k] = myGlobalElements[k];
// Append one more.
a[numMyElements] = map.NumGlobalElements();
extendedMap = std::make_shared<Tpetra::Map<int,int>>(
numGlobalElements,
numMyElements+1,
&a[0],
map.IndexBase(),
comm
);
} else {
extendedMap = std::make_shared<Tpetra::Map<int,int>>(
numGlobalElements,
numMyElements,
myGlobalElements,
map.IndexBase(),
comm
);
}
return extendedMap;
}
//==========================================================================
Komplex_Ordering::Komplex_Ordering(const Epetra_BlockMap& Map,
Komplex_KForms KForm,
bool IsOneObject)
: P_(Map),
D_(Map),
KForm_(KForm),
StoredKForm_(K1),
IsOneObject_(IsOneObject)
{
if (KForm_ == K1 || KForm_ == K2) {
P_.PutScalar(1.0);
} else {
P_.PutScalar(-1.0);
}
if (KForm_ == K1 || KForm_ == K3) {
D_.PutScalar(1.0);
} else {
for (int i = 0; i < Map.NumGlobalElements(); i+=2) {
D_.ReplaceGlobalValue(i, 0, 1.0);
D_.ReplaceGlobalValue(i+1, 0, -1.0);
}
}
}
