/usr/include/dolfin/la/GenericTensor.h is in libdolfin1.0-dev 1.0.0-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 | // Copyright (C) 2007-2011 Anders Logg
//
// This file is part of DOLFIN.
//
// DOLFIN 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 3 of the License, or
// (at your option) any later version.
//
// DOLFIN 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 DOLFIN. If not, see <http://www.gnu.org/licenses/>.
//
// Modified by Garth N. Wells, 2007-2011.
// Modified by Ola Skavhaug, 2007.
// Modified by Martin Alnæs, 2008.
//
// First added: 2007-01-17
// Last changed: 2011-11-11
#ifndef __GENERIC_TENSOR_H
#define __GENERIC_TENSOR_H
#include <exception>
#include <typeinfo>
#include <boost/shared_ptr.hpp>
#include <dolfin/log/log.h>
#include <dolfin/common/types.h>
#include <dolfin/common/Variable.h>
namespace dolfin
{
class GenericSparsityPattern;
class LinearAlgebraFactory;
/// This class defines a common interface for arbitrary rank tensors.
class GenericTensor : public virtual Variable
{
public:
/// Destructor
virtual ~GenericTensor() {}
//--- Basic GenericTensor interface ---
/// Return true if tensor is distributed
virtual bool distributed() const = 0;
/// Initialize zero tensor using sparsity pattern
virtual void init(const GenericSparsityPattern& sparsity_pattern) = 0;
/// Return copy of tensor
virtual GenericTensor* copy() const = 0;
/// Return tensor rank (number of dimensions)
virtual uint rank() const = 0;
/// Return size of given dimension
virtual uint size(uint dim) const = 0;
/// Return local ownership range
virtual std::pair<uint, uint> local_range(uint dim) const = 0;
/// Get block of values
virtual void get(double* block, const uint* num_rows,
const uint * const * rows) const = 0;
/// Set block of values
virtual void set(const double* block, const uint* num_rows,
const uint * const * rows) = 0;
/// Add block of values
virtual void add(const double* block,
const std::vector<const std::vector<uint>* >& rows) = 0;
/// Add block of values
virtual void add(const double* block,
const std::vector<std::vector<uint> >& rows) = 0;
/// Add block of values
virtual void add(const double* block, const uint* num_rows,
const uint * const * rows) = 0;
/// Set all entries to zero and keep any sparse structure
virtual void zero() = 0;
/// Finalize assembly of tensor
virtual void apply(std::string mode) = 0;
/// Return informal string representation (pretty-print)
virtual std::string str(bool verbose) const = 0;
//--- Special functions, downcasting to concrete types ---
/// Return linear algebra backend factory
virtual LinearAlgebraFactory& factory() const = 0;
/// Cast a GenericTensor to its derived class (const version)
template<typename T> const T& down_cast() const
{
try
{
return dynamic_cast<const T&>(*instance());
}
catch (std::exception& e)
{
dolfin_error("GenericTensor.h",
"down-cast tensor to requested type",
"%s", e.what());
}
// Return something to keep the compiler happy. Code will never be reached.
return dynamic_cast<const T&>(*instance());
}
/// Cast a GenericTensor to its derived class (non-const version)
template<typename T> T& down_cast()
{
try
{
return dynamic_cast<T&>(*instance());
}
catch (std::exception& e)
{
dolfin_error("GenericTensor.h",
"down-cast tensor to requested type",
"%s", e.what());
}
// Return something to keep the compiler happy. Code will never be reached.
return dynamic_cast<T&>(*instance());
}
/// Cast a GenericTensor shared ptr to its derived class. Caller
/// must check for success (returns null if cast fails).
template<typename X, typename Y>
static boost::shared_ptr<X> down_cast(const boost::shared_ptr<Y> A)
{
// Try to down cast shared pointer
boost::shared_ptr<X> _A = boost::dynamic_pointer_cast<X>(A);
// If down cast fails, try to get shared ptr instance to unwrapped object
if (!_A)
{
// Try to get instance to unwrapped object and cast
if (A->shared_instance())
_A = boost::dynamic_pointer_cast<X>(A->shared_instance());
}
return _A;
}
/// Check whether the GenericTensor instance matches a specific type
template<typename T> bool has_type() const
{ return bool(dynamic_cast<const T*>(instance())); }
//--- Special functions, intended for library use only ---
/// Return concrete instance / unwrap (const version)
virtual const GenericTensor* instance() const
{ return this; }
/// Return concrete instance / unwrap (non-const version)
virtual GenericTensor* instance()
{ return this; }
/// Return concrete shared ptr instance / unwrap (const version)
virtual boost::shared_ptr<const GenericTensor> shared_instance() const
{ return boost::shared_ptr<const GenericTensor>(); }
/// Return concrete shared ptr instance / unwrap
virtual boost::shared_ptr<GenericTensor> shared_instance()
{ return boost::shared_ptr<GenericTensor>(); }
/// Assignment (must be overloaded by subclass)
virtual const GenericTensor& operator= (const GenericTensor& x)
{
dolfin_error("GenericTensor.h",
"assign tensor",
"Assignment operator not implemented by subclass");
return *this;
}
};
}
#endif
|