~corrado-maurini/dolfin/tao

 

struct CompareIndex

{

  { return index == entry.first; }

  private:

};

 

//-----------------------------------------------------------------------------

  }

 

  //primary_dim = sparsity_pattern.primary_dim();

  if (primary_dim == 1)

    primary_codim = 0;

 

  _local_range = tensor_layout.local_range(primary_dim);

  num_codim_entities = tensor_layout.size(primary_codim);

 

 

  _values.resize(num_primary_entiries);

 

  //}

}

//-----------------------------------------------------------------------------

{

  if (dim > 1)

  {

  }

}

//-----------------------------------------------------------------------------

{

  dolfin_assert(dim < 2);

  if (primary_dim == 0)

//-----------------------------------------------------------------------------

void STLMatrix::zero()

{

  for (slice = _values.begin(); slice != _values.end(); ++slice)

    for (entry = slice->begin(); entry != slice->end(); ++entry)

      entry->second = 0.0;

}

//-----------------------------------------------------------------------------

{

  // Perform a simple linear search along each column. Otherwise,

  // append the value (calling push_back).

 

 

  if (primary_dim == 1)

  {

    dim = n;

  }

 

  // Iterate over primary dimension

  {

    // Global primary index

 

    // Check if I is a local row/column

    if (I < _local_range.second && I >= _local_range.first)

    {

 

      assert(I_local < _values.size());

 

      // Iterate over co-dimension

      {

 

        // Global index

 

        // Check if entry exists and insert

              = std::find_if(slice.begin(), slice.end(), CompareIndex(J));

        if (entry != slice.end())

          entry->second += block[pos];

    else

    {

      // Iterate over columns

      {

        // Global column, coordinate

 

        coord = off_processs_data.find(global_coordinate);

        if (coord == off_processs_data.end())

          off_processs_data[global_coordinate] = block[pos];

  Timer("Apply (matrix)");

 

  // Data to send

  std::vector<double> send_non_local_vals;

 

  dolfin::MPI::all_gather(_local_range, process_ranges);

 

  // Communicate off-process data

  for (entry = off_processs_data.begin(); entry != off_processs_data.end(); ++entry)

  {

 

    // FIXME: This can be more efficient by storing sparsity pattern,

    //        or caching owning process for repeated assembly

 

    // Get owning process

    {

      if (global_row < process_ranges[proc].second &&  global_row >= process_ranges[proc].first)

      {

  }

 

  // Send/receive data

  std::vector<double> received_non_local_vals;

  dolfin::MPI::distribute(send_non_local_rows, destinations, received_non_local_rows);

  dolfin::MPI::distribute(send_non_local_cols, destinations, received_non_local_cols);

  assert(received_non_local_rows.size() == received_non_local_vals.size());

 

  // Add/insert off-process data

  {

    dolfin_assert(received_non_local_rows[i] < _local_range.second && received_non_local_rows[i] >= _local_range.first);

    assert(I_local < _values.size());

 

          = std::find_if(_values[I_local].begin(), _values[I_local].end(), CompareIndex(J));

    if (entry != _values[I_local].end())

      entry->second += received_non_local_vals[i];

    error("Do not know to comput %s norm for STLMatrix", norm_type.c_str());

 

  double _norm = 0.0;

  {

      _norm += _values[i][j].second*_values[i][j].second;

  }

  return std::sqrt(dolfin::MPI::sum(_norm));

}

//-----------------------------------------------------------------------------

                       std::vector<double>& values) const

{

  if (primary_dim == 1)

  }

 

  dolfin_assert(row < _local_range.second && row >= _local_range.first);

  dolfin_assert(local_row < _values.size());

  columns.resize(_values[local_row].size());

  values.resize(_values[local_row].size());

  {

    columns[i] = _values[local_row][i].first;

    values[i]  = _values[local_row][i].second;

  }

}

//-----------------------------------------------------------------------------

{

  if (primary_dim == 1)

  {

                 "STLMatrix::ident can only be used with row-wise storage.");

  }

 

  {

    if (global_row >= row_range.first && global_row < row_range.second)

    {

      dolfin_assert(local_row < _values.size());

        _values[local_row][i].second = 0.0;

 

      // Place one on diagonal

          = std::find_if(_values[local_row].begin(), _values[local_row].end(),

                         CompareIndex(global_row));

 

//-----------------------------------------------------------------------------

const STLMatrix& STLMatrix::operator*= (double a)

{

  for (row = _values.begin(); row != _values.end(); ++row)

    for (entry = row->begin(); entry != row->end(); ++entry)

      entry->second *=a;

    }

 

    s << str(false) << std::endl << std::endl;

    {

      // Sort row data by colmun index

      std::sort(data.begin(), data.end());

 

      // Set precision

 

      // Format matrix

      line << "|";

      for (entry = data.begin(); entry != data.end(); ++entry)

        line << " (" << i << ", " << entry->first << ", " << entry->second << ")";

      line << " |";

    return STLFactoryCSC::instance();

}

//-----------------------------------------------------------------------------

{

  return dolfin::MPI::sum(local_nnz());

}

//-----------------------------------------------------------------------------

{

    _nnz += _values[i].size();

  return _nnz;

}