Intrepid MiniTensor: Changed from raw pointers to Teuchos::ArrayRCP
for components.
Intrepid MiniTensor: Changed initialization of components to use Teuchos::null
Tpetra: Map: Removed a reduction from noncontiguous Map constructor.

Tpetra::Map's "noncontiguous" constructor (that takes an
ArrayView<const GO> of GIDs owned by the calling process) was doing
an all-reduce to figure out whether the Map is distributed or locally
replicated.  "Distributed" means that there is at least one process
which owns strictly fewer elements than the global number of elements
in the Map.  It turns out that when GO (GlobalOrdinal) is a signed
integer type (the common case -- either int, long, or long long), this
all-reduce can be combined with the previous max all-reduce that
computes the global min and max GIDs.  This commit applies this
optimization.

I've also changes the Packet type for Boolean all-reduces in Map from
char to int.  Teuchos::reduceAll has a specialization for Packet=int
that should make those all-reduces faster.  (It skips over Teuchos::Comm
serialization and uses the predefined MPI_Op, rather than serializing
and using a custom MPI_Op.)  There is no specialization yet for Packet=
char because I couldn't get that specialization to compile correctly a
while back.
Tpetra: Map: Optimized contiguous uniform getRemoteIndexList lookups.

Map's getRemoteIndexList method, which finds the process rank (and
optionally the local index on that process) for a list of global
indices, is an important kernel in setting up an Import or Export.  The
Map's Directory implements this method.  The version of Directory that
the Map uses depends on the Map's attributes: for example, whether it
is distributed, and whether the global indices are contiguous.

Previously, Tpetra had lacked a special-case implementation of Directory
for contiguous uniform Maps.  This case requires only O(1) space and
time to do the getRemoteIndexList lookup, which is not currently true of
a general (possibly nonuniform) contiguous Map.  Contiguous uniform Maps
are an important use case, both for basic Tpetra examples, and as part
of the implementation of noncontiguous Maps.  A noncontiguous Map's
Directory uses a contiguous uniform Map (the "directory Map") to
distribute the noncontiguous Directory information.  Every lookup (call
to getRemoteIndexList) for a noncontiguous Map requires a lookup on the
contiguous uniform Map.

This commit adds a special-case implementation of Directory
(Details::ContiguousUniformDirectory) for contiguous uniform Maps.
As promised, it requires only O(1) space and time to do a lookup for one
global index.  (The current implementation for a general contiguous Map
requires O(P) storage and in the worst case O(log P) time to do a lookup
for one global index, where P is the number of processes in the Map's
communicator.)  This should speed up lookups for the noncontiguous case
as well.

Build/Test Cases Summary
Enabled Packages: Tpetra, Belos, Ifpack2, Xpetra, MueLu
0) MPI_DEBUG => Test case MPI_DEBUG was not run! => Does not affect push readiness! (-1.00 min)
1) SERIAL_RELEASE => Test case SERIAL_RELEASE was not run! => Does not affect push readiness! (-1.00 min)
2) MPI_DEBUG_SS => passed: passed=169,notpassed=0 (7.97 min)
3) SERIAL_RELEASE_SS => passed: passed=154,notpassed=0 (4.45 min)
Other local commits for this build/test group: 7f4374e
Teko: Fixing some compiler warnings
Panzer: Methods for modifying the integration order and basis order

This is to allow a somewhat automated way to update the basis order
and integration order to be used to increase the order of the discretizations.
Tpetra: CrsGraph: Changed Boolean all-reduce type from char to int.

Teuchos::reduceAll is probably faster for Packet type = int than for
Packet type = char, so int should be the preferred type for Boolean
all-reduces.  I found all the places in CrsGraph that were using char
as the Boolean reduction type, and replaced them with int.
Tpetra: CrsGraph: Removed an all-reduce from makeColMap.

The all-reduce was a sanity check to ensure that all the column indices
added to the graph occur on some process in the domain Map.  Now, the
check only happens in a debug build (HAVE_TPETRA_DEBUG).

I also added lots of internal documentation to makeColMap, to explain
how we could create the Import object using the information we compute
(and currently throw away) in that method, and how much we could save by
doing so.  Implementing this optimization should speed up fillComplete
for all use cases.

Build/Test Cases Summary
Enabled Packages: Tpetra, Belos, Ifpack2, Xpetra, MueLu
0) MPI_DEBUG => Test case MPI_DEBUG was not run! => Does not affect push readiness! (-1.00 min)
1) SERIAL_RELEASE => Test case SERIAL_RELEASE was not run! => Does not affect push readiness! (-1.00 min)
2) MPI_DEBUG_SS => passed: passed=168,notpassed=0 (5.65 min)
3) SERIAL_RELEASE_SS => passed: passed=153,notpassed=0 (1.70 min)
Other local commits for this build/test group: b55a3d0
MueLu,Xpetra: whitespace cleanup
SEACAS: suplib - fix compilation warning for older gcc use in Trilinos

(From Sierra)
SEACAS: svdi - compilation warning fix

(From Sierra)
IOSS: Add option to obtain the "implicit ids" for nodes which are the 1..count - temporary to facilitate Salinas porting to stk_mesh

(From Sierra)

Build/Test Cases Summary
Enabled Packages: SEACASIoss, SEACASSuplib, SEACAS
Disabled Packages: Panzer,PyTrilinos
Enabled all Forward Packages
0) MPI_DEBUG => Skipped configure, build, test due to no enabled packages! => Does not affect push readiness! (-1.00 min)
1) SERIAL_RELEASE => Skipped configure, build, test due to no enabled packages! => Does not affect push readiness! (-1.00 min)
2) MPI_DEBUG_SS => passed: passed=21,notpassed=0 (24.46 min)
3) SERIAL_RELEASE_SS => passed: passed=22,notpassed=0 (26.49 min)
Other local commits for this build/test group: 54a4750, faaf8fe
 A better default for concurrentPartCount in MJ of Zoltan2.
 This should help Muelu.
Merge branch 'master' of software.sandia.gov:/space/git/Trilinos
Ifpack2:
    Added templated applyTempl() methods to ILUT, Diagonal, and Additive
    Schwarz. These methods are templated on the DomainScalar and RangeScalar
    types of the input and output multivectors, which may be different than
    the scalar type of the preconditioner.

    This allows a preconditioner which is stored in float to be applied to double
    precision multivectors, for example. For ILUT, I changed the normal apply()
    method to simply call the applyTempl() method, because the underlying sparse
    triangular solves are already templated in the CrsMatrix class. For Diagonal, I
    left the code for apply(), since the applyTempl() version requires some temporary
    multivectors for the scalar conversion. For AdditiveSchwarz, I left the
    code for apply() so that it can still be used for Ifpack2 preconditioners
    whose applyTempl() methods haven't been implemented yet. It would make
    sense to have apply() just call applyTempl() once the other Ifpack2
    preconditioners implement it.

    Implementing the applyTempl() for AdditiveSchwarz required adding templated
    versions of a few methods in OverlappingRowMatrix, SingletonFilter,
    and ReorderFilter. These templated methods allow those classes to perform
    operations on multivectors with scalar types different from the scalar type
    of the preconditioner. I also went ahead and implemented applyTempl()
    methods for these classes.

    Tpetra:
    Added an experimental ApplyOp class in the details namespace. This is an
    example of how to use the applyTempl() methods in the Ifpack2 classes
    above. The reasoning behind using the applyTempl() functions from
    an outside class that "wraps" the class is that C++ doesn't allow templated
    virtual functions, so the normal apply function within the preconditioner
    can't have these extra template parameters. There is more discussion in
    the comments in CrsMatrix, which has similar templated localMultiply() and
    localSolve() methods, meant to be used with the CrsMatrixMultiplyOp class.

Build/Test Cases Summary
Enabled Packages: Ifpack2, Tpetra
Enabled all Forward Packages
0) MPI_DEBUG => passed: passed=689,notpassed=0 (46.04 min)
1) SERIAL_RELEASE => passed: passed=648,notpassed=0 (22.61 min)
Belos: Have BelosBlockCGIter class use the fixed Teuchos_SerialSpdDenseSolver
class instead of calling LAPACK wrappers directly. This will allow the code
to compile in extended precision.

Build/Test Cases Summary
Enabled Packages: Belos
Enabled all Forward Packages
0) MPI_DEBUG => passed: passed=491,notpassed=0 (38.12 min)
1) SERIAL_RELEASE => passed: passed=460,notpassed=0 (17.79 min)
Piro: Simplified ObserverBase interface

There was no sufficient benefit in having an optional user-specified
type for the stamp.
Tpetra: Import, Export: Improved public docs; optimized a loop.

I've heard some users complain that the terms "Import" and "Export"
are confusing.  Their meaning does differ somewhat from the same terms
in Zoltan, for example.  I added a paragraph to the documentation of
these classes which explains (one plausible reason) why we use these
names.  I also took the opportunity to optimize a loop in Import's
initialization.
Tpetra: CrsMatrix: Improved performance of getLocalDiagCopy.

This method was calling Map::isSameAs every time to check that the input
Vector's Map is the same as the matrix's row Map.  This is both slow (it
requires an all-reduce) and too strict of a requirement (the input
Vector only needs to be compatible).  This commit limits the check to
debug mode (HAVE_TPETRA_DEBUG), and changes the check from isSameAs to
isCompatible.

Build/Test Cases Summary
Enabled Packages: Tpetra, Belos, Ifpack2, Xpetra
0) MPI_DEBUG => Test case MPI_DEBUG was not run! => Does not affect push readiness! (-1.00 min)
1) SERIAL_RELEASE => Test case SERIAL_RELEASE was not run! => Does not affect push readiness! (-1.00 min)
2) MPI_DEBUG_SS => passed: passed=135,notpassed=0 (3.39 min)
3) SERIAL_RELEASE_SS => passed: passed=119,notpassed=0 (1.46 min)
Other local commits for this build/test group: 0d1d3bd
Ifpack2: Took out macro telling the test routine to not build BlockCG
when QD is enabled, because BlockCG compiles with QD now (after adding
support for SerialSpdDenseSolver). However, PseudoBlockGmres seems to
not be building with QD currently, so I have disabled that test for now.

Build/Test Cases Summary
Enabled Packages: Ifpack2
Enabled all Forward Packages
0) MPI_DEBUG => passed: passed=21,notpassed=0 (16.55 min)
1) SERIAL_RELEASE => passed: passed=17,notpassed=0 (4.88 min)