Tpetra_Export.hpp

// @HEADER
// ***********************************************************************
// 
//          Tpetra: Templated Linear Algebra Services Package
//                 Copyright (2004) Sandia Corporation
// 
// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
// license for use of this work by or on behalf of the U.S. Government.
// 
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//  
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//  
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
// Questions? Contact Michael A. Heroux (maherou@sandia.gov) 
// 
// ***********************************************************************
// @HEADER

#ifndef TPETRA_EXPORT_HPP
#define TPETRA_EXPORT_HPP

#include <Teuchos_Object.hpp>
#include <Teuchos_as.hpp>
#include <Teuchos_OrdinalTraits.hpp>
#include <Teuchos_RCP.hpp>
#include <Teuchos_Array.hpp>
#include <Teuchos_ArrayRCP.hpp>
#include "Tpetra_Map.hpp"
#include "Tpetra_Util.hpp"
#include "Tpetra_ImportExportData.hpp"

// FINISH: this class is not finished yet

namespace Tpetra {


  template <typename Ordinal>
  class Export: public Teuchos::Object {

  public:



    Export(const Map<Ordinal> & source, const Map<Ordinal> & target);

    Export(Export<Ordinal> const& rhs);

    ~Export();




    Ordinal getNumSameIDs() const;

    Ordinal getNumPermuteIDs() const;

    Teuchos::ArrayView<const Ordinal> getPermuteFromLIDs() const;

    Teuchos::ArrayView<const Ordinal> getPermuteToLIDs() const;

    Ordinal getNumRemoteIDs() const;

    Teuchos::ArrayView<const Ordinal> getRemoteLIDs() const;

    Ordinal getNumExportIDs() const;

    Teuchos::ArrayView<const Ordinal> getExportLIDs() const;

    Teuchos::ArrayView<const Ordinal> getExportImageIDs() const;

    const Map<Ordinal> & getSourceMap() const;

    const Map<Ordinal> & getTargetMap() const;

    Distributor<Ordinal>& getDistributor() const;

    Export<Ordinal>& operator = (const Export<Ordinal> & Source);




    virtual void print(std::ostream& os) const;


  private:

    Teuchos::RCP<ImportExportData<Ordinal> > ExportData_;

    // subfunctions used by constructor
    //==============================================================================
    // sets up numSameIDs_, numPermuteIDs_, and numExportIDs_
    // these variables are already initialized to 0 by the ImportExportData ctr.
    // also sets up permuteToLIDs_, permuteFromLIDs_, exportGIDs_, and exportLIDs_
    void setupSamePermuteExport();
    void setupRemote();
  };

  template <typename Ordinal>
    Export<Ordinal>::Export(const Map<Ordinal> & source, const Map<Ordinal> & target)
    : Teuchos::Object("Tpetra::Export")
    , ExportData_()
  {
    TEST_FOR_EXCEPT(true); // not yet supported
    ExportData_ = Teuchos::rcp(new ImportExportData<Ordinal>(source, target));
    // call subfunctions
    setupSamePermuteExport();
    if(source.isDistributed()) {
      setupRemote();
    }
  }

  template <typename Ordinal>
  Export<Ordinal>::Export(const Export<Ordinal> & rhs)
  : Teuchos::Object(rhs.label())
  , ExportData_(rhs.ExportData_)
  {
    TEST_FOR_EXCEPT(true); // not yet supported
  }

  template <typename Ordinal>
  Export<Ordinal>::~Export() 
  {}

  template <typename Ordinal>
  Ordinal Export<Ordinal>::getNumSameIDs() const {
    return ExportData_->numSameIDs_;
  }

  template <typename Ordinal>
  Ordinal Export<Ordinal>::getNumPermuteIDs() const {
    return ExportData_->numPermuteIDs_;
  }

  template <typename Ordinal>
  Teuchos::ArrayView<const Ordinal> 
  Export<Ordinal>::getPermuteFromLIDs() const {
    return ExportData_->permuteFromLIDs_();
  }

  template <typename Ordinal>
  Teuchos::ArrayView<const Ordinal>
  Export<Ordinal>::getPermuteToLIDs() const {
    return ExportData_->permuteToLIDs_();
  }

  template <typename Ordinal>
  Ordinal Export<Ordinal>::getNumRemoteIDs() const {
    return ExportData_->numRemoteIDs_;
  }

  template <typename Ordinal>
  Teuchos::ArrayView<const Ordinal> 
  Export<Ordinal>::getRemoteLIDs() const {
    return ExportData_->remoteLIDs_();
  }

  template <typename Ordinal>
  Ordinal Export<Ordinal>::getNumExportIDs() const {
    return ExportData_->numExportIDs_;
  }

  template <typename Ordinal>
  Teuchos::ArrayView<const Ordinal> 
  Export<Ordinal>::getExportLIDs() const {
    return ExportData_->exportLIDs_();
  }

  template <typename Ordinal>
  Teuchos::ArrayView<const Ordinal> 
  Export<Ordinal>::getExportImageIDs() const {
    return ExportData_->exportImageIDs_();
  }

  template <typename Ordinal>
  const Map<Ordinal> & 
  Export<Ordinal>::getSourceMap() const {
    return ExportData_->source_;
  }

  template <typename Ordinal>
  const Map<Ordinal> & 
  Export<Ordinal>::getTargetMap() const {
    return ExportData_->target_;
  }

  template <typename Ordinal>
  Distributor<Ordinal>& 
  Export<Ordinal>::getDistributor() const {
    return ExportData_->distributor_;
  }

  template <typename Ordinal>
  Export<Ordinal>& 
  Export<Ordinal>::operator=(const Export<Ordinal> & Source) 
  {
    ExportData_ = Source.ExportData_;
    return *this;
  }

  template <typename Ordinal>
  void Export<Ordinal>::print(std::ostream& os) const 
  {
    using std::endl;
    os << "Export Data Members:" << endl;
    os << "permuteToLIDs:   {"; std::copy(getPermuteToLIDs().begin()  ,getPermuteToLIDs().end()  ,std::ostream_iterator<Ordinal>(os," ")); os << " }" << endl;
    os << "permuteFromLIDs: {"; std::copy(getPermuteFromLIDs().begin(),getPermuteFromLIDs().end(),std::ostream_iterator<Ordinal>(os," ")); os << " }" << endl;
    os << "remoteLIDs:      {"; std::copy(getRemoteLIDs().begin()     ,getRemoteLIDs().end()     ,std::ostream_iterator<Ordinal>(os," ")); os << " }" << endl;
    os << "exportLIDs:      {"; std::copy(getExportLIDs().begin()     ,getExportLIDs().end()     ,std::ostream_iterator<Ordinal>(os," ")); os << " }" << endl;
    os << "exportImageIDs:  {"; std::copy(getExportImageIDs().begin() ,getExportImageIDs().end() ,std::ostream_iterator<Ordinal>(os," ")); os << " }" << endl;
    os << "numSameIDs   : " << getNumSameIDs() << endl;
    os << "numPermuteIDs: " << getNumPermuteIDs() << endl;
    os << "numRemoteIDs : " << getNumRemoteIDs() << endl;
    os << "numExportIDs : " << getNumExportIDs() << endl;
    os << "\nsource: " << endl << getSourceMap();
    os << "\ntarget: " << endl << getTargetMap();
  }


  template <typename Ordinal>
  void Export<Ordinal>::setupSamePermuteExport() 
  {
    const Map<Ordinal> & source = getSourceMap();
    const Map<Ordinal> & target = getTargetMap();
    Teuchos::ArrayView<const Ordinal> sourceGIDs = source.getMyGlobalEntries();
    Teuchos::ArrayView<const Ordinal> targetGIDs = target.getMyGlobalEntries();

    // -- compute numSameIDs_ ---
    // go through GID lists of source and target. if the ith GID on both is the same, 
    // increment numSameIDs_ and try the next. as soon as you come to a pair that don't
    // match, give up.
    typename Teuchos::ArrayView<const Ordinal>::iterator sourceIter = sourceGIDs.begin(),
                                                         targetIter = targetGIDs.begin();
    while( sourceIter != sourceGIDs.end() && targetIter != targetGIDs.end() && *sourceIter == *targetIter )
    {
      ++ExportData_->numSameIDs_;
      ++sourceIter;
      ++targetIter;
    }
    // sourceIter should now point to the GID of the first non-same entry or at the end of targetGIDs

    // -- compute numPermuteIDs and numRemoteIDs --
    // -- fill permuteToLIDs_, permuteFromLIDs_, remoteGIDs_, and remoteLIDs_ --
    // go through remaining entries in sourceGIDs. if target owns that GID, 
    // increment numPermuteIDs_, and add entries to permuteToLIDs_ and permuteFromLIDs_.
    // otherwise increment numExportIDs_ and add entries to exportLIDs_ and exportGIDs_.
    for(; sourceIter != sourceGIDs.end(); ++sourceIter) {
      if(target.isMyGlobalIndex(*sourceIter)) {
        // both source and target list this GID (*targetIter)
        // determine the LIDs for this GID on both Maps and add them to the permutation lists
        ExportData_->permuteToLIDs_.push_back(  target.getLocalIndex(*sourceIter));
        ExportData_->permuteFromLIDs_.push_back(source.getLocalIndex(*sourceIter));
      }
      else {
        ExportData_->exportLIDs_.push_back(source.getLocalIndex(*sourceIter));
        ExportData_->exportGIDs_.push_back(*sourceIter);
      }
    }
    ExportData_->numPermuteIDs_ = Teuchos::as<Ordinal>(ExportData_->permuteToLIDs.size());
    ExportData_->numExportIDs_  = Teuchos::as<Ordinal>(ExportData_->exportLIDs_.size());

    /* FINISH
    TEST_FOR_EXCEPTION( (ExportData_->numExportIDs_ > zero) && (!source.isDistributed()), std::runtime_error, 
        "Tpetra::Export<" << Teuchos::OrdinalTraits<Ordinal>::name() 
        << ">::setupSamePermuteExport(): Source has export LIDs but Source is not distributed globally.");

    // -- compute exportImageIDs_ --
    // get list of images that own the GIDs in exportGIDs_ (in the target Map)
    // check exportImageIDs_ for any -1 entries (nobody owns that GID in the target Map)
    target.getRemoteIDList(ExportData_->exportGIDs_, ExportData_->exportImageIDs_);
    Ordinal count = std::count(ExportData_->exportImageIDs_.begin(), ExportData_->exportImageIDs_.end(), negOne);
    if(count > zero) {
      throw reportError("Source has GIDs not found in Target.", 2);
    }
    */
  }

  template <typename Ordinal>
  void Export<Ordinal>::setupRemote() 
  {
    Ordinal const zero = Teuchos::OrdinalTraits<Ordinal>::zero();
    Ordinal const one = Teuchos::OrdinalTraits<Ordinal>::one();
    Map<Ordinal> const& target = getTargetMap();

    // make sure export IDs are ordered by image
    // sort exportImageIDs_ in ascending order,
    // and apply the same permutation to exportGIDs_ and exportLIDs_.
    sortArrays(ExportData_->exportImageIDs_, ExportData_->exportGIDs_, ExportData_->exportLIDs_);

    // Construct list of entries that calling image needs to send as a result
    // of everyone asking for what it needs to receive.
    ExportData_->distributor_.createFromSends(ExportData_->numExportIDs_, ExportData_->exportImageIDs_, true, ExportData_->numRemoteIDs_);
    // -- numRemoteIDs_ is now defined --

    // Use comm plan with ExportGIDs to find out who is sending to us and
    // get proper ordering of GIDs for remote entries 
    // (that we will convert to LIDs when done).
    Teuchos::RCP< Teuchos::Comm<Ordinal> > comm = ExportData_->platform_->createOrdinalComm();
    comm->doPostsAndWaits(ExportData_->distributor_, ExportData_->exportGIDs_, one, ExportData_->remoteGIDs_);
    // -- remoteGIDs_ is now defined --

    // Remote IDs come in as GIDs, convert to LIDs
    for(Ordinal i = zero; i < ExportData_->numRemoteIDs_; i++) {
      ExportData_->remoteLIDs_.push_back(target.getLID(ExportData_->remoteGIDs_[i]));
    }
  }

} // namespace Tpetra

#endif // TPETRA_EXPORT_HPP

---