* case the matrix needs to be
* copied from deal.II format.
*/
- std::auto_ptr<Epetra_Map> vector_distributor;
+ std_cxx1x::shared_ptr<Epetra_Map> vector_distributor;
};
* which is passed down to the
* Trilinos solver.
*/
- std::auto_ptr<Epetra_LinearProblem> linear_problem;
+ std_cxx1x::shared_ptr<Epetra_LinearProblem> linear_problem;
/**
* A structure that contains
* which is passed down to the
* Trilinos solver.
*/
- std::auto_ptr<Epetra_LinearProblem> linear_problem;
+ std_cxx1x::shared_ptr<Epetra_LinearProblem> linear_problem;
/**
* A structure that contains
* the Trilinos solver and
* preconditioner objects.
*/
- std::auto_ptr<Amesos_BaseSolver> solver;
+ std_cxx1x::shared_ptr<Amesos_BaseSolver> solver;
/**
* Store a copy of the flags for this
* assigns parts of the matrix
* to the individual processes.
*/
- std::auto_ptr<Epetra_Map> column_space_map;
+ std_cxx1x::shared_ptr<Epetra_Map> column_space_map;
/**
* A sparse matrix object in
* a sparse matrix, is set in
* the constructor.
*/
- std::auto_ptr<Epetra_FECrsMatrix> matrix;
+ std_cxx1x::shared_ptr<Epetra_FECrsMatrix> matrix;
/**
* Trilinos doesn't allow to mix
* assigns parts of the matrix
* to the individual processes.
*/
- std::auto_ptr<Epetra_Map> column_space_map;
+ std_cxx1x::shared_ptr<Epetra_Map> column_space_map;
/**
* A boolean variable to hold
* allows for adding non-local
* elements to the pattern.
*/
- std::auto_ptr<Epetra_FECrsGraph> graph;
+ std_cxx1x::shared_ptr<Epetra_FECrsGraph> graph;
friend class SparsityPatternIterators::const_iterator;
friend class SparsityPatternIterators::const_iterator::Accessor;
const dealii::Vector<number> &v)
{
if (&*vector != 0 && vector->Map().SameAs(parallel_partitioner))
- vector = std::auto_ptr<Epetra_FEVector>
+ vector = std_cxx1x::shared_ptr<Epetra_FEVector>
(new Epetra_FEVector(parallel_partitioner));
const int size = parallel_partitioner.NumMyElements();
{
if (size() != v.size())
{
- vector = std::auto_ptr<Epetra_FEVector>
+ vector = std_cxx1x::shared_ptr<Epetra_FEVector>
(new Epetra_FEVector(Epetra_Map (v.size(), 0,
#ifdef DEAL_II_COMPILER_SUPPORTS_MPI
Epetra_MpiComm(MPI_COMM_SELF)
Vector::Vector (const dealii::Vector<number> &v)
{
Epetra_LocalMap map ((int)v.size(), 0, Utilities::Trilinos::comm_self());
- vector = std::auto_ptr<Epetra_FEVector> (new Epetra_FEVector(map));
+ vector = std_cxx1x::shared_ptr<Epetra_FEVector> (new Epetra_FEVector(map));
*this = v;
}
{
if (size() != v.size())
{
- vector.release();
+ vector.reset();
Epetra_LocalMap map ((int)v.size(), 0,
Utilities::Trilinos::comm_self());
- vector = std::auto_ptr<Epetra_FEVector> (new Epetra_FEVector(map));
+ vector = std_cxx1x::shared_ptr<Epetra_FEVector> (new Epetra_FEVector(map));
}
const Epetra_Map & map = vector_partitioner();
* type. Requires an existing
* Epetra_Map for storing data.
*/
- std::auto_ptr<Epetra_FEVector> vector;
+ std_cxx1x::shared_ptr<Epetra_FEVector> vector;
/**
ExcMessage("Vector has not been constructed properly."));
if (fast == false || local_range() != v.local_range())
- vector = std::auto_ptr<Epetra_FEVector>(new Epetra_FEVector(*v.vector));
+ vector = std_cxx1x::shared_ptr<Epetra_FEVector>(new Epetra_FEVector(*v.vector));
}
// first create a solver object if this
// is necessary
- if (solver_data == 0)
+ if (&*solver_data == 0)
{
solver_data.reset (new SolverData());
// elements.
vector_distributor.reset (new Epetra_Map(n_rows, 0, communicator));
- if (Matrix==0)
+ if (&*Matrix==0)
Matrix = std_cxx1x::shared_ptr<SparseMatrix> (new SparseMatrix());
Matrix->reinit (*vector_distributor, *vector_distributor,
// todo: find a way to read out ML's data
// sizes
- if (Matrix != 0)
+ if (&*Matrix != 0)
memory += Matrix->memory_consumption();
return memory;
}
// interface.
SparseMatrix::SparseMatrix ()
:
- column_space_map (std::auto_ptr<Epetra_Map>
+ column_space_map (std_cxx1x::shared_ptr<Epetra_Map>
(new Epetra_Map (0, 0,
Utilities::Trilinos::comm_self()))),
- matrix (std::auto_ptr<Epetra_FECrsMatrix>
+ matrix (std_cxx1x::shared_ptr<Epetra_FECrsMatrix>
(new Epetra_FECrsMatrix(View, *column_space_map,
*column_space_map, 0))),
last_action (Zero),
SparseMatrix::SparseMatrix (const Epetra_Map &input_map,
const unsigned int n_max_entries_per_row)
:
- column_space_map (std::auto_ptr<Epetra_Map>
+ column_space_map (std_cxx1x::shared_ptr<Epetra_Map>
(new Epetra_Map (input_map))),
- matrix (std::auto_ptr<Epetra_FECrsMatrix>
+ matrix (std_cxx1x::shared_ptr<Epetra_FECrsMatrix>
(new Epetra_FECrsMatrix(Copy, *column_space_map,
int(n_max_entries_per_row), false))),
last_action (Zero),
SparseMatrix::SparseMatrix (const Epetra_Map &input_map,
const std::vector<unsigned int> &n_entries_per_row)
:
- column_space_map (std::auto_ptr<Epetra_Map>
+ column_space_map (std_cxx1x::shared_ptr<Epetra_Map>
(new Epetra_Map (input_map))),
- matrix (std::auto_ptr<Epetra_FECrsMatrix>
+ matrix (std_cxx1x::shared_ptr<Epetra_FECrsMatrix>
(new Epetra_FECrsMatrix(Copy, *column_space_map,
(int*)const_cast<unsigned int*>(&(n_entries_per_row[0])),
false))),
const Epetra_Map &input_col_map,
const unsigned int n_max_entries_per_row)
:
- column_space_map (std::auto_ptr<Epetra_Map>
+ column_space_map (std_cxx1x::shared_ptr<Epetra_Map>
(new Epetra_Map (input_col_map))),
- matrix (std::auto_ptr<Epetra_FECrsMatrix>
+ matrix (std_cxx1x::shared_ptr<Epetra_FECrsMatrix>
(new Epetra_FECrsMatrix(Copy, input_row_map,
int(n_max_entries_per_row), false))),
last_action (Zero),
const Epetra_Map &input_col_map,
const std::vector<unsigned int> &n_entries_per_row)
:
- column_space_map (std::auto_ptr<Epetra_Map>
+ column_space_map (std_cxx1x::shared_ptr<Epetra_Map>
(new Epetra_Map (input_col_map))),
- matrix (std::auto_ptr<Epetra_FECrsMatrix>
+ matrix (std_cxx1x::shared_ptr<Epetra_FECrsMatrix>
(new Epetra_FECrsMatrix(Copy, input_row_map,
(int*)const_cast<unsigned int*>(&(n_entries_per_row[0])),
false))),
const unsigned int n,
const unsigned int n_max_entries_per_row)
:
- column_space_map (std::auto_ptr<Epetra_Map>
+ column_space_map (std_cxx1x::shared_ptr<Epetra_Map>
(new Epetra_Map (n, 0,
Utilities::Trilinos::comm_self()))),
// can't do so in parallel, where the
// information from columns is only
// available when entries have been added
- matrix (std::auto_ptr<Epetra_FECrsMatrix>
+ matrix (std_cxx1x::shared_ptr<Epetra_FECrsMatrix>
(new Epetra_FECrsMatrix(Copy,
Epetra_Map (m, 0,
Utilities::Trilinos::comm_self()),
const unsigned int n,
const std::vector<unsigned int> &n_entries_per_row)
:
- column_space_map (std::auto_ptr<Epetra_Map>
+ column_space_map (std_cxx1x::shared_ptr<Epetra_Map>
(new Epetra_Map (n, 0,
Utilities::Trilinos::comm_self()))),
- matrix (std::auto_ptr<Epetra_FECrsMatrix>
+ matrix (std_cxx1x::shared_ptr<Epetra_FECrsMatrix>
(new Epetra_FECrsMatrix(Copy,
Epetra_Map (m, 0,
Utilities::Trilinos::comm_self()),
const MPI_Comm &communicator,
const unsigned int n_max_entries_per_row)
:
- column_space_map (std::auto_ptr<Epetra_Map>
+ column_space_map (std_cxx1x::shared_ptr<Epetra_Map>
(new Epetra_Map(parallel_partitioning.
make_trilinos_map(communicator, false)))),
- matrix (std::auto_ptr<Epetra_FECrsMatrix>
+ matrix (std_cxx1x::shared_ptr<Epetra_FECrsMatrix>
(new Epetra_FECrsMatrix(Copy,
*column_space_map,
n_max_entries_per_row,
const MPI_Comm &communicator,
const std::vector<unsigned int> &n_entries_per_row)
:
- column_space_map (std::auto_ptr<Epetra_Map>
+ column_space_map (std_cxx1x::shared_ptr<Epetra_Map>
(new Epetra_Map(parallel_partitioning.
make_trilinos_map(communicator, false)))),
- matrix (std::auto_ptr<Epetra_FECrsMatrix>
+ matrix (std_cxx1x::shared_ptr<Epetra_FECrsMatrix>
(new Epetra_FECrsMatrix(Copy,
*column_space_map,
(int*)const_cast<unsigned int*>(&(n_entries_per_row[0])),
const MPI_Comm &communicator,
const unsigned int n_max_entries_per_row)
:
- column_space_map (std::auto_ptr<Epetra_Map>
+ column_space_map (std_cxx1x::shared_ptr<Epetra_Map>
(new Epetra_Map(col_parallel_partitioning.
make_trilinos_map(communicator, false)))),
- matrix (std::auto_ptr<Epetra_FECrsMatrix>
+ matrix (std_cxx1x::shared_ptr<Epetra_FECrsMatrix>
(new Epetra_FECrsMatrix(Copy,
row_parallel_partitioning.
make_trilinos_map(communicator, false),
const MPI_Comm &communicator,
const std::vector<unsigned int> &n_entries_per_row)
:
- column_space_map (std::auto_ptr<Epetra_Map>
+ column_space_map (std_cxx1x::shared_ptr<Epetra_Map>
(new Epetra_Map(col_parallel_partitioning.
make_trilinos_map(communicator, false)))),
- matrix (std::auto_ptr<Epetra_FECrsMatrix>
+ matrix (std_cxx1x::shared_ptr<Epetra_FECrsMatrix>
(new Epetra_FECrsMatrix(Copy,
row_parallel_partitioning.
make_trilinos_map(communicator, false),
SparseMatrix::SparseMatrix (const SparsityPattern &sparsity_pattern)
:
- column_space_map (std::auto_ptr<Epetra_Map>
+ column_space_map (std_cxx1x::shared_ptr<Epetra_Map>
(new Epetra_Map (sparsity_pattern.domain_partitioner()))),
- matrix (std::auto_ptr<Epetra_FECrsMatrix>
+ matrix (std_cxx1x::shared_ptr<Epetra_FECrsMatrix>
(new Epetra_FECrsMatrix(Copy,
sparsity_pattern.trilinos_sparsity_pattern(),
false))),
SparseMatrix::SparseMatrix (const SparseMatrix &input_matrix)
:
Subscriptor(),
- column_space_map (std::auto_ptr<Epetra_Map>
+ column_space_map (std_cxx1x::shared_ptr<Epetra_Map>
(new Epetra_Map (input_matrix.domain_partitioner()))),
- matrix (std::auto_ptr<Epetra_FECrsMatrix>
+ matrix (std_cxx1x::shared_ptr<Epetra_FECrsMatrix>
(new Epetra_FECrsMatrix(*input_matrix.matrix))),
last_action (Zero),
compressed (true)
*matrix = *m.matrix;
else
{
- column_space_map = std::auto_ptr<Epetra_Map>
+ column_space_map = std_cxx1x::shared_ptr<Epetra_Map>
(new Epetra_Map (m.domain_partitioner()));
- matrix = std::auto_ptr<Epetra_FECrsMatrix>
+ matrix = std_cxx1x::shared_ptr<Epetra_FECrsMatrix>
(new Epetra_FECrsMatrix(*m.matrix));
}
sparsity_pattern.n_cols()));
}
- column_space_map = std::auto_ptr<Epetra_Map> (new Epetra_Map (input_col_map));
+ column_space_map = std_cxx1x::shared_ptr<Epetra_Map> (new Epetra_Map (input_col_map));
std::vector<int> n_entries_per_row(n_rows);
// processor, we can directly assign the
// columns as well. Compare this with bug
// # 4123 in the Sandia Bugzilla.
- std::auto_ptr<Epetra_CrsGraph> graph;
+ std_cxx1x::shared_ptr<Epetra_CrsGraph> graph;
if (input_row_map.Comm().NumProc() > 1)
- graph = std::auto_ptr<Epetra_CrsGraph>
+ graph = std_cxx1x::shared_ptr<Epetra_CrsGraph>
(new Epetra_CrsGraph (Copy, input_row_map,
&n_entries_per_row[input_row_map.MinMyGID()], true));
else
- graph = std::auto_ptr<Epetra_CrsGraph>
+ graph = std_cxx1x::shared_ptr<Epetra_CrsGraph>
(new Epetra_CrsGraph (Copy, input_row_map, input_col_map,
&n_entries_per_row[input_row_map.MinMyGID()], true));
sparsity_pattern.n_cols()));
// And now finally generate the matrix.
- matrix = std::auto_ptr<Epetra_FECrsMatrix>
+ matrix = std_cxx1x::shared_ptr<Epetra_FECrsMatrix>
(new Epetra_FECrsMatrix(Copy, *graph, false));
last_action = Zero;
// sparsity pattern.
matrix.reset();
- column_space_map = std::auto_ptr<Epetra_Map>
+ column_space_map = std_cxx1x::shared_ptr<Epetra_Map>
(new Epetra_Map (sparsity_pattern.domain_partitioner()));
- matrix = std::auto_ptr<Epetra_FECrsMatrix>
+ matrix = std_cxx1x::shared_ptr<Epetra_FECrsMatrix>
(new Epetra_FECrsMatrix(Copy, sparsity_pattern.trilinos_sparsity_pattern(),
false));
compress();
{
matrix.reset();
- column_space_map = std::auto_ptr<Epetra_Map>
+ column_space_map = std_cxx1x::shared_ptr<Epetra_Map>
(new Epetra_Map (sparse_matrix.domain_partitioner()));
- matrix = std::auto_ptr<Epetra_FECrsMatrix>
+ matrix = std_cxx1x::shared_ptr<Epetra_FECrsMatrix>
(new Epetra_FECrsMatrix(Copy, sparse_matrix.trilinos_sparsity_pattern(),
false));
goto set_matrix_values;
{
- std::auto_ptr<SparsityPattern> trilinos_sparsity;
- trilinos_sparsity = std::auto_ptr<SparsityPattern> (new SparsityPattern());
+ std_cxx1x::shared_ptr<SparsityPattern> trilinos_sparsity;
+ trilinos_sparsity = std_cxx1x::shared_ptr<SparsityPattern> (new SparsityPattern());
trilinos_sparsity->reinit (input_row_map, input_col_map, sparsity_pattern);
reinit (*trilinos_sparsity);
}
Assert (input_matrix.Filled()==true,
ExcMessage("Input CrsMatrix has not called FillComplete()!"));
- column_space_map = std::auto_ptr<Epetra_Map>
+ column_space_map = std_cxx1x::shared_ptr<Epetra_Map>
(new Epetra_Map (input_matrix.DomainMap()));
const Epetra_CrsGraph *graph = &input_matrix.Graph();
- matrix = std::auto_ptr<Epetra_FECrsMatrix>
+ matrix = std_cxx1x::shared_ptr<Epetra_FECrsMatrix>
(new Epetra_FECrsMatrix(Copy, *graph, false));
matrix->FillComplete (*column_space_map, input_matrix.RangeMap(), true);
matrix.reset();
column_space_map.reset();
- column_space_map = std::auto_ptr<Epetra_Map>
+ column_space_map = std_cxx1x::shared_ptr<Epetra_Map>
(new Epetra_Map (0, 0, Utilities::Trilinos::comm_self()));
- matrix = std::auto_ptr<Epetra_FECrsMatrix>
+ matrix = std_cxx1x::shared_ptr<Epetra_FECrsMatrix>
(new Epetra_FECrsMatrix(View, *column_space_map, 0));
matrix->FillComplete();
:
compressed (true)
{
- column_space_map = std::auto_ptr<Epetra_Map>
+ column_space_map = std_cxx1x::shared_ptr<Epetra_Map>
(new Epetra_Map (0, 0, Utilities::Trilinos::comm_self()));
- graph = std::auto_ptr<Epetra_FECrsGraph>
+ graph = std_cxx1x::shared_ptr<Epetra_FECrsGraph>
(new Epetra_FECrsGraph(View, *column_space_map, *column_space_map, 0));
graph->FillComplete();
}
SparsityPattern::SparsityPattern (const SparsityPattern &input_sparsity)
:
Subscriptor(),
- column_space_map (std::auto_ptr<Epetra_Map>
+ column_space_map (std_cxx1x::shared_ptr<Epetra_Map>
(new Epetra_Map(0, 0, Utilities::Trilinos::comm_self()))),
compressed (false),
- graph (std::auto_ptr<Epetra_FECrsGraph>
+ graph (std_cxx1x::shared_ptr<Epetra_FECrsGraph>
(new Epetra_FECrsGraph(View, *column_space_map,
*column_space_map, 0)))
{
const Epetra_Map &input_col_map,
const unsigned int n_entries_per_row)
{
- column_space_map = std::auto_ptr<Epetra_Map> (new Epetra_Map (input_col_map));
+ column_space_map = std_cxx1x::shared_ptr<Epetra_Map> (new Epetra_Map (input_col_map));
graph.reset();
compressed = false;
// processor, we can directly assign the
// columns as well.
if (input_row_map.Comm().NumProc() > 1)
- graph = std::auto_ptr<Epetra_FECrsGraph>
+ graph = std_cxx1x::shared_ptr<Epetra_FECrsGraph>
(new Epetra_FECrsGraph(Copy, input_row_map, n_entries_per_row, false));
else
- graph = std::auto_ptr<Epetra_FECrsGraph>
+ graph = std_cxx1x::shared_ptr<Epetra_FECrsGraph>
(new Epetra_FECrsGraph(Copy, input_row_map, input_col_map,
n_entries_per_row, false));
}
ExcDimensionMismatch (n_entries_per_row.size(),
input_row_map.NumGlobalElements()));
- column_space_map = std::auto_ptr<Epetra_Map> (new Epetra_Map (input_col_map));
+ column_space_map = std_cxx1x::shared_ptr<Epetra_Map> (new Epetra_Map (input_col_map));
graph.reset();
compressed = false;
if (input_row_map.Comm().NumProc() > 1)
- graph = std::auto_ptr<Epetra_FECrsGraph>
+ graph = std_cxx1x::shared_ptr<Epetra_FECrsGraph>
(new Epetra_FECrsGraph(Copy, input_row_map,
n_entries_per_row[input_row_map.MinMyGID()],
false));
else
- graph = std::auto_ptr<Epetra_FECrsGraph>
+ graph = std_cxx1x::shared_ptr<Epetra_FECrsGraph>
(new Epetra_FECrsGraph(Copy, input_row_map, input_col_map,
n_entries_per_row[input_row_map.MinMyGID()],
false));
ExcDimensionMismatch (sp.n_cols(),
input_col_map.NumGlobalElements()));
- column_space_map = std::auto_ptr<Epetra_Map> (new Epetra_Map (input_col_map));
+ column_space_map = std_cxx1x::shared_ptr<Epetra_Map> (new Epetra_Map (input_col_map));
graph.reset();
compressed = false;
n_entries_per_row[row-input_row_map.MinMyGID()] = sp.row_length(row);
if (input_row_map.Comm().NumProc() > 1)
- graph = std::auto_ptr<Epetra_FECrsGraph>
+ graph = std_cxx1x::shared_ptr<Epetra_FECrsGraph>
(new Epetra_FECrsGraph(Copy, input_row_map,
n_entries_per_row[0],
false));
else
- graph = std::auto_ptr<Epetra_FECrsGraph>
+ graph = std_cxx1x::shared_ptr<Epetra_FECrsGraph>
(new Epetra_FECrsGraph(Copy, input_row_map, input_col_map,
n_entries_per_row[0],
false));
column_space_map.reset();
graph.reset();
- column_space_map = std::auto_ptr<Epetra_Map>
+ column_space_map = std_cxx1x::shared_ptr<Epetra_Map>
(new Epetra_Map (0, 0, Utilities::Trilinos::comm_self()));
- graph = std::auto_ptr<Epetra_FECrsGraph>
+ graph = std_cxx1x::shared_ptr<Epetra_FECrsGraph>
(new Epetra_FECrsGraph(View, *column_space_map, *column_space_map, 0));
graph->FillComplete();
Vector::Vector ()
{
last_action = Zero;
- vector = std::auto_ptr<Epetra_FEVector>
+ vector = std_cxx1x::shared_ptr<Epetra_FEVector>
(new Epetra_FEVector(Epetra_Map(0,0,0,Utilities::Trilinos::comm_self())));
}
VectorBase()
{
last_action = Zero;
- vector = std::auto_ptr<Epetra_FEVector> (new Epetra_FEVector(*v.vector));
+ vector = std_cxx1x::shared_ptr<Epetra_FEVector> (new Epetra_FEVector(*v.vector));
}
last_action = Zero;
if (input_map.SameAs(v.vector->Map()) == true)
- vector = std::auto_ptr<Epetra_FEVector> (new Epetra_FEVector(*v.vector));
+ vector = std_cxx1x::shared_ptr<Epetra_FEVector> (new Epetra_FEVector(*v.vector));
else
{
- vector = std::auto_ptr<Epetra_FEVector> (new Epetra_FEVector(input_map));
+ vector = std_cxx1x::shared_ptr<Epetra_FEVector> (new Epetra_FEVector(input_map));
reinit (v, false, true);
}
}
last_action = Zero;
- vector = std::auto_ptr<Epetra_FEVector>
+ vector = std_cxx1x::shared_ptr<Epetra_FEVector>
(new Epetra_FEVector(parallel_partitioner.make_trilinos_map(communicator,
true)));
reinit (v, false, true);
const bool fast)
{
if (!vector->Map().SameAs(input_map))
- vector = std::auto_ptr<Epetra_FEVector> (new Epetra_FEVector(input_map));
+ vector = std_cxx1x::shared_ptr<Epetra_FEVector> (new Epetra_FEVector(input_map));
else if (fast == false)
{
const int ierr = vector->PutScalar(0.);
{
vector.reset();
- vector = std::auto_ptr<Epetra_FEVector>
+ vector = std_cxx1x::shared_ptr<Epetra_FEVector>
(new Epetra_FEVector(v.vector->Map()));
last_action = Zero;
}
v.block(0).vector_partitioner().Comm());
if (import_data == false)
- vector = std::auto_ptr<Epetra_FEVector> (new Epetra_FEVector (new_map));
+ vector = std_cxx1x::shared_ptr<Epetra_FEVector> (new Epetra_FEVector (new_map));
Teuchos::RCP<Epetra_FEVector> actual_vec = (import_data == true) ?
Teuchos::rcp (new Epetra_FEVector (new_map), true) :
else
{
vector.reset();
- vector = std::auto_ptr<Epetra_FEVector>
+ vector = std_cxx1x::shared_ptr<Epetra_FEVector>
(new Epetra_FEVector(*v.vector));
last_action = Zero;
}
if (vector->Map().SameAs(m.col_partitioner()) == false)
{
Epetra_Map map = m.col_partitioner();
- vector = std::auto_ptr<Epetra_FEVector> (new Epetra_FEVector(map));
+ vector = std_cxx1x::shared_ptr<Epetra_FEVector> (new Epetra_FEVector(map));
}
Epetra_Import data_exchange (vector->Map(), v.vector->Map());
{
last_action = Zero;
Epetra_LocalMap map (0, 0, Utilities::Trilinos::comm_self());
- vector = std::auto_ptr<Epetra_FEVector> (new Epetra_FEVector(map));
+ vector = std_cxx1x::shared_ptr<Epetra_FEVector> (new Epetra_FEVector(map));
}
{
last_action = Zero;
Epetra_LocalMap map ((int)n, 0, Utilities::Trilinos::comm_self());
- vector = std::auto_ptr<Epetra_FEVector> (new Epetra_FEVector (map));
+ vector = std_cxx1x::shared_ptr<Epetra_FEVector> (new Epetra_FEVector (map));
}
Epetra_LocalMap map (input_map.NumGlobalElements(),
input_map.IndexBase(),
input_map.Comm());
- vector = std::auto_ptr<Epetra_FEVector> (new Epetra_FEVector(map));
+ vector = std_cxx1x::shared_ptr<Epetra_FEVector> (new Epetra_FEVector(map));
}
Epetra_SerialComm());
(void)communicator;
#endif
- vector = std::auto_ptr<Epetra_FEVector> (new Epetra_FEVector(map));
+ vector = std_cxx1x::shared_ptr<Epetra_FEVector> (new Epetra_FEVector(map));
}
Epetra_LocalMap map (v.vector->Map().NumGlobalElements(),
v.vector->Map().IndexBase(),
v.vector->Map().Comm());
- vector = std::auto_ptr<Epetra_FEVector> (new Epetra_FEVector(map));
+ vector = std_cxx1x::shared_ptr<Epetra_FEVector> (new Epetra_FEVector(map));
if (vector->Map().SameAs(v.vector->Map()) == true)
{
Epetra_LocalMap map ((int)n, 0,
Utilities::Trilinos::comm_self());
- vector = std::auto_ptr<Epetra_FEVector> (new Epetra_FEVector (map));
+ vector = std_cxx1x::shared_ptr<Epetra_FEVector> (new Epetra_FEVector (map));
}
else if (fast == false)
{
Epetra_LocalMap map (input_map.NumGlobalElements(),
input_map.IndexBase(),
input_map.Comm());
- vector = std::auto_ptr<Epetra_FEVector> (new Epetra_FEVector (map));
+ vector = std_cxx1x::shared_ptr<Epetra_FEVector> (new Epetra_FEVector (map));
}
else if (fast == false)
{
Epetra_SerialComm());
(void)communicator;
#endif
- vector = std::auto_ptr<Epetra_FEVector> (new Epetra_FEVector(map));
+ vector = std_cxx1x::shared_ptr<Epetra_FEVector> (new Epetra_FEVector(map));
}
else if (fast == false)
{
Epetra_LocalMap map (v.vector->GlobalLength(),
v.vector->Map().IndexBase(),
v.vector->Comm());
- vector = std::auto_ptr<Epetra_FEVector> (new Epetra_FEVector(map));
+ vector = std_cxx1x::shared_ptr<Epetra_FEVector> (new Epetra_FEVector(map));
}
else
{
Epetra_LocalMap map (v.vector->Map().NumGlobalElements(),
v.vector->Map().IndexBase(),
v.vector->Comm());
- vector = std::auto_ptr<Epetra_FEVector> (new Epetra_FEVector(map));
+ vector = std_cxx1x::shared_ptr<Epetra_FEVector> (new Epetra_FEVector(map));
}
reinit (v, false, true);
Epetra_LocalMap map (v.vector->Map().NumGlobalElements(),
v.vector->Map().IndexBase(),
v.vector->Comm());
- vector = std::auto_ptr<Epetra_FEVector> (new Epetra_FEVector(map));
+ vector = std_cxx1x::shared_ptr<Epetra_FEVector> (new Epetra_FEVector(map));
}
const int ierr = vector->Update(1.0, *v.vector, 0.0);
last_action (Zero),
compressed (true),
#ifdef DEAL_II_COMPILER_SUPPORTS_MPI
- vector(std::auto_ptr<Epetra_FEVector>
+ vector(std_cxx1x::shared_ptr<Epetra_FEVector>
(new Epetra_FEVector(
Epetra_Map(0,0,Epetra_MpiComm(MPI_COMM_SELF)))))
#else
- vector(std::auto_ptr<Epetra_FEVector>
+ vector(std_cxx1x::shared_ptr<Epetra_FEVector>
(new Epetra_FEVector(
Epetra_Map(0,0,Epetra_SerialComm()))))
#endif
Subscriptor(),
last_action (Zero),
compressed (true),
- vector(std::auto_ptr<Epetra_FEVector>
+ vector(std_cxx1x::shared_ptr<Epetra_FEVector>
(new Epetra_FEVector(*v.vector)))
{}
Epetra_Map map (0, 0, Epetra_SerialComm());
#endif
- vector = std::auto_ptr<Epetra_FEVector> (new Epetra_FEVector(map));
+ vector = std_cxx1x::shared_ptr<Epetra_FEVector> (new Epetra_FEVector(map));
last_action = Zero;
}
{
vector.reset();
last_action = Zero;
- vector = std::auto_ptr<Epetra_FEVector>(new Epetra_FEVector(*v.vector));
+ vector = std_cxx1x::shared_ptr<Epetra_FEVector>(new Epetra_FEVector(*v.vector));
}
else
{