src/identityoperator.h

Go to the documentation of this file.

//
// C++ Interface: identityoperator
//
// Description: Identity operator
//
//
// Author: Roman Geus <roman.geus@psi.ch>, (C) 2004
//
// Copyright: See COPYING file that comes with this distribution
//
//

#ifndef IDENTITY_OPERATOR_H
#define IDENTITY_OPERATOR_H

#include "Epetra_Operator.h"

class Epetra_MultiVector;
class Epetra_Map;
class Epetra_Comm;

class IdentityOperator : public Epetra_Operator {
    public:
        IdentityOperator(const Epetra_Map& domain_map,
                         const Epetra_Map& range_map,
                         const Epetra_Comm& comm)
            : domain_map_(domain_map),
              range_map_(range_map),
              comm_(comm),
              use_transpose_(false)
        { }

        ~IdentityOperator() {}

        int SetUseTranspose(bool use_transpose) {
            use_transpose_ = use_transpose;
            return 0;
        }

        int Apply(const Epetra_MultiVector& X, Epetra_MultiVector& Y) const {
            if (&X != &Y) {
                // X and Y are not the same obj: copy X to Y, vector by vector

                if (!X.Map().SameAs(OperatorDomainMap()))
                    EPETRA_CHK_ERR(-1);
                if (!Y.Map().SameAs(OperatorRangeMap()))
                    EPETRA_CHK_ERR(-2);
                if (Y.NumVectors() != X.NumVectors())
                    EPETRA_CHK_ERR(-3);
                if (!domain_map_.SameAs(range_map_))
                    EPETRA_CHK_ERR(-4);

                int num_vectors = X.NumVectors();
                int my_length = X.MyLength();

                for (int i = 0; i < num_vectors; i ++) {
                    memcpy(Y[i], X[i], my_length * sizeof(double));
                }
            }
            return 0;
        }

        int ApplyInverse(const Epetra_MultiVector& X, Epetra_MultiVector& Y) const {
            return Apply(X, Y);
        }

        double NormInf() const {
            return 0.0;
        }

        const char * Label() const {
            return "Identity operator";
        }

        bool UseTranspose() const {
            return use_transpose_;
        }

        bool HasNormInf() const {
            return false;
        }

        const Epetra_Comm& Comm() const {
            return comm_;
        }

        const Epetra_Map & OperatorDomainMap() const {
            return domain_map_;
        }

        const Epetra_Map & OperatorRangeMap() const {
            return range_map_;
        }

    private:
        const Epetra_Map& domain_map_;
        const Epetra_Map& range_map_;
        const Epetra_Comm& comm_;
        bool use_transpose_;
};

#endif

---