diff --git a/src/opt/mpi/include/rrange.cc.h b/src/opt/mpi/include/rrange.cc.h
new file mode 100644
index 0000000..d3152fa
--- /dev/null
+++ b/src/opt/mpi/include/rrange.cc.h
@@ -0,0 +1,243 @@
+// -*- C++ -*-
+/**
+   
+   @file opt/mpi/include/rrange.cc.h
+   @brief RRange and RIndex declaration.
+   
+   Copyright (c) 2024 Christian Zimmermann. All rights reserved.
+   Mail: chizeta@f3l.de
+   
+**/
+
+#ifndef __cxz_mpi_rrange_cc_h__
+#define __cxz_mpi_rrange_cc_h__
+
+#include "rrange.h"
+
+namespace CNORXZ
+{
+    namespace mpi
+    {
+
+	template <class IndexI, class IndexK>
+	RIndex<IndexI,IndexK>::RIndex(const RIndex& in) :
+	    mRange(in.mRange),
+	    mI(std::make_shared<Index>(mRange->local())),
+	    mK(std::make_shared<YIndex>(mRange->geom()))
+	{
+	    *this = in.lex();
+	}
+
+	template <class IndexI, class IndexK>
+	RIndex& RIndex<IndexI,IndexK>::operator=(const RIndex& in)
+	{
+	    mRange = in.mRange;
+	    mI = std::make_shared<Index>(mRange->local());
+	    mK = std::make_shared<YIndex>(mRange->geom());
+	    *this = in.lex();
+	    return *this;
+	}
+
+	template <class IndexI, class IndexK>
+	RIndex<IndexI,IndexK>::RIndex(const RangePtr& global, SizeT lexpos = 0) :
+	    mRange(rangeCast<RangeType>(global)),
+	    mI(std::make_shared<Index>(mRange->local())),
+	    mK(std::make_shared<YIndex>(mRange->geom()))
+	{
+	    *this = lexpos;
+	}
+
+	template <class IndexI, class IndexK>
+	RIndex<IndexI,IndexK>::RIndex(const Sptr<Index>& local) :
+	{
+	    //!!!
+	}
+	    
+	template <class IndexI, class IndexK>
+	RIndex<IndexI,IndexK>& RIndex<IndexI,IndexK>::operator=(SizeT pos)
+	{
+	    // pos is the lexicographic position of the global range.
+	    // Hence, have to consider the rank geometry.
+	    if constexpr(has_static_sub<IndexI>::value or has_static_sub<IndexK>::value){
+		
+	    }
+	    else {
+
+	    }
+	    return *this;
+	}
+
+	template <class IndexI, class IndexK>
+	RIndex<IndexI,IndexK>& RIndex<IndexI,IndexK>::operator++()
+	{
+	    
+	    return *this;
+	}
+
+	template <class IndexI, class IndexK>
+	RIndex<IndexI,IndexK>& RIndex<IndexI,IndexK>::operator--()
+	{
+
+	    return *this;
+	}
+
+	template <class IndexI, class IndexK>
+	RIndex<IndexI,IndexK> RIndex<IndexI,IndexK>::operator+(Int n) const
+	{
+
+	}
+
+	template <class IndexI, class IndexK>
+	RIndex<IndexI,IndexK> RIndex<IndexI,IndexK>::operator-(Int n) const
+	{
+
+	}
+
+	template <class IndexI, class IndexK>
+	SizeT RIndex<IndexI,IndexK>::operator-(const RIndex& i) const
+	{
+
+	}
+
+	template <class IndexI, class IndexK>
+	RIndex<IndexI,IndexK>& RIndex<IndexI,IndexK>::operator+=(Int n)
+	{
+
+	    return *this;
+	}
+
+	template <class IndexI, class IndexK>
+	RIndex<IndexI,IndexK>& RIndex<IndexI,IndexK>::operator-=(Int n)
+	{
+
+	    return *this;
+	}
+
+	template <class IndexI, class IndexK>
+	SizeT RIndex<IndexI,IndexK>::lex() const
+	{
+
+	}
+
+	template <class IndexI, class IndexK>
+	constexpr RIndex<IndexI,IndexK>::decltype(auto) pmax() const
+	{
+
+	}
+	    
+
+	template <class IndexI, class IndexK>
+	constexpr RIndex<IndexI,IndexK>::decltype(auto) lmax() const
+	{
+
+	}
+
+	template <class IndexI, class IndexK>
+	IndexId<0> RIndex<IndexI,IndexK>::id() const
+	{
+
+	}
+
+	template <class IndexI, class IndexK>
+	MetaType RIndex<IndexI,IndexK>::operator*() const
+	{
+
+	}
+	
+	template <class IndexI, class IndexK>
+	constexpr SizeT RIndex<IndexI,IndexK>::dim() const
+	{
+
+	}
+
+	template <class IndexI, class IndexK>
+	Sptr<RangeType> RIndex<IndexI,IndexK>::range() const
+	{
+
+	}
+
+	template <class IndexI, class IndexK>
+	template <SizeT I>
+	decltype(auto) RIndex<IndexI,IndexK>::stepSize(const IndexId<I>& id) const
+	{
+
+	}
+
+	template <class IndexI, class IndexK>
+	String RIndex<IndexI,IndexK>::stringMeta() const
+	{
+
+	}
+
+	template <class IndexI, class IndexK>
+	MetaType RIndex<IndexI,IndexK>::meta() const
+	{
+
+	}
+
+	template <class IndexI, class IndexK>
+	RIndex<IndexI,IndexK>& RIndex<IndexI,IndexK>::at(const MetaType& metaPos)
+	{
+
+	}
+
+	template <class IndexI, class IndexK>
+	RangePtr RIndex<IndexI,IndexK>::prange(const RIndex<IndexI,IndexK>& last) const
+	{
+
+	}
+
+	template <class IndexI, class IndexK>
+	auto RIndex<IndexI,IndexK>::deepFormat() const
+	{
+
+	}
+
+	template <class IndexI, class IndexK>
+	auto RIndex<IndexI,IndexK>::deepMax() const
+	{
+
+	}
+
+	template <class IndexI, class IndexK>
+	RIndex<IndexI,IndexK>& RIndex<IndexI,IndexK>::reformat(const Vector<SizeT>& f, const Vector<SizeT>& s)
+	{
+
+	}
+
+	template <class IndexI, class IndexK>
+	template <class Xpr, class F>
+	constexpr decltype(auto) RIndex<IndexI,IndexK>::ifor(const Xpr& xpr, F&& f) const
+	{
+
+	}
+
+	template <class IndexI, class IndexK>
+	bool RIndex<IndexI,IndexK>::formatIsTrivial() const
+	{
+
+	}
+
+	template <class IndexI, class IndexK>
+	decltype(auto) RIndex<IndexI,IndexK>::xpr(const Sptr<RIndex<IndexI,IndexK>>& _this) const
+	{
+
+	}
+
+	template <class IndexI, class IndexK>
+	int RIndex<IndexI,IndexK>::rank() const
+	{
+
+	}
+
+	template <class IndexI, class IndexK>
+	Sptr<Index> RIndex<IndexI,IndexK>::local() const
+	{
+
+	}
+	
+	
+    } // namespace mpi
+} // namespace CNORXZ
+
+#endif
diff --git a/src/opt/mpi/include/rrange.h b/src/opt/mpi/include/rrange.h
index df8c11e..7b0caf0 100644
--- a/src/opt/mpi/include/rrange.h
+++ b/src/opt/mpi/include/rrange.h
@@ -1,7 +1,7 @@
 // -*- C++ -*-
 /**
    
-   @file opt/include/rrange.h
+   @file opt/mpi/include/rrange.h
    @brief RRange and RIndex declaration.
    
    Copyright (c) 2024 Christian Zimmermann. All rights reserved.
@@ -16,179 +16,217 @@
 
 namespace CNORXZ
 {
-
-    /** ****
-	Specific index for RRange.
-	@tparam Index Local index type.
-     */
-    template <class Index>
-    class RIndex : public IndexInterface<RIndex<Index>,typename Index::MetaType>
+    namespace mpi
     {
-    public:
-	typedef IndexInterface<RIndex<Index>,typename Index::MetaType> IB;
-	typedef typename Index::MetaType MetaType;
-	typedef RRange<typename Index::RangeType> RangeType;
 
-	INDEX_RANDOM_ACCESS_ITERATOR_DEFS(MetaType);
+	/** ****
+	    Specific index for RRange.
+	    Every call on an instance of this class has to be done on each rank.
+	    @tparam IndexI Index type used to indicate local position.
+	    @tparam IndexK Index type used to indicate the rank.
+	*/
+	template <class IndexI, class IndexK>
+	class RIndex : public IndexInterface<RIndex<IndexI,IndexK>,typename Index::MetaType>
+	{
+	public:
+	    typedef IndexInterface<RIndex<IndexI,IndexK>,typename Index::MetaType> IB;
+	    typedef typename Index::MetaType MetaType;
+	    typedef RRange<typename Index::RangeType> RangeType;
 
-	// constructors!!!
+	    INDEX_RANDOM_ACCESS_ITERATOR_DEFS(MetaType);
+
+	    // constructors!!!
+	    /** Default constructor. */
+	    RIndex() = default;
+
+	    /** Move constructor (default). */
+	    RIndex(RIndex&& in) = default;
+
+	    /** Move assignment (default). */
+	    RIndex& operator=(RIndex&& in) = default;
+
+	    /** Copy constructor (no default, copy local index instance). */
+	    RIndex(const RIndex& in);
+
+	    /** Copy assignment (no default, copy local index instance). */
+	    RIndex& operator=(const RIndex& in);
+
+	    /** Construct from global range and format.
+		@param global Pointer to global range; this can be a RRange or the bare range (will be converted to a RRange).
+		@param lexpos Start position.
+	     */
+	    RIndex(const RangePtr& global, SizeT lexpos = 0);
+
+	    /** Construct from local index. */
+	    RIndex(const Sptr<IndexI,IndexK>& local);
+	    
+	    /** @copydoc IndexInterface::operator=(SizeT) */
+	    RIndex& operator=(SizeT pos);
+
+	    /** @copydoc IndexInterface::operator++() */
+	    RIndex& operator++();
+
+	    /** @copydoc IndexInterface::operator--() */
+	    RIndex& operator--();
+
+	    /** @copydoc IndexInterface::operator+() */
+	    RIndex operator+(Int n) const;
+
+	    /** @copydoc IndexInterface::operator-() */
+	    RIndex operator-(Int n) const;
+
+	    /** @copydoc IndexInterface::operator-(CIndex) */
+	    SizeT operator-(const RIndex& i) const;
+
+	    /** @copydoc IndexInterface::operator+=() */
+	    RIndex& operator+=(Int n);
+
+	    /** @copydoc IndexInterface::operator-=() */
+	    RIndex& operator-=(Int n);
+
+	    /** @copydoc IndexInterface::lex() */
+	    SizeT lex() const;
+
+	    /** @copydoc IndexInterface::pmax() */
+	    constexpr decltype(auto) pmax() const;
+
+	    /** @copydoc IndexInterface::lmax() */
+	    constexpr decltype(auto) lmax() const;
+
+	    /** @copydoc IndexInterface::id() */
+	    IndexId<0> id() const;
+
+	    /** @copydoc IndexInterface::operator*() */
+	    MetaType operator*() const;
 	
-	/** @copydoc IndexInterface::operator=(SizeT) */
-	RIndex& operator=(SizeT pos);
+	    /** @copydoc IndexInterface::dim() */
+	    constexpr SizeT dim() const;
 
-	/** @copydoc IndexInterface::operator++() */
-	RIndex& operator++();
+	    /** @copydoc IndexInterface::range() */
+	    Sptr<RangeType> range() const;
 
-	/** @copydoc IndexInterface::operator--() */
-	RIndex& operator--();
+	    /** @copydoc IndexInterface::stepSize() */
+	    template <SizeT I>
+	    decltype(auto) stepSize(const IndexId<I>& id) const;
 
-	/** @copydoc IndexInterface::operator+() */
-	RIndex operator+(Int n) const;
+	    /** @copydoc IndexInterface::stringMeta() */
+	    String stringMeta() const;
 
-	/** @copydoc IndexInterface::operator-() */
-	RIndex operator-(Int n) const;
+	    /** @copydoc IndexInterface::meta() */
+	    MetaType meta() const;
 
-	/** @copydoc IndexInterface::operator-(CIndex) */
-	SizeT operator-(const RIndex& i) const;
+	    /** @copydoc IndexInterface::at() */
+	    RIndex& at(const MetaType& metaPos);
 
-	/** @copydoc IndexInterface::operator+=() */
-	RIndex& operator+=(Int n);
+	    /** @copydoc IndexInterface::prange() */
+	    RangePtr prange(const RIndex<IndexI,IndexK>& last) const;
 
-	/** @copydoc IndexInterface::operator-=() */
-	RIndex& operator-=(Int n);
+	    /** @copydoc IndexInterface::deepFormat() */
+	    auto deepFormat() const;
 
-	/** @copydoc IndexInterface::lex() */
-	SizeT lex() const;
+	    /** @copydoc IndexInterface::deepMax() */
+	    auto deepMax() const;
 
-	/** @copydoc IndexInterface::pmax() */
-	constexpr decltype(auto) pmax() const;
+	    /** @copydoc IndexInterface::reformat() */
+	    RIndex& reformat(const Vector<SizeT>& f, const Vector<SizeT>& s);
 
-	/** @copydoc IndexInterface::lmax() */
-	constexpr decltype(auto) lmax() const;
+	    /** @copydoc IndexInterface::ifor() */
+	    template <class Xpr, class F>
+	    constexpr decltype(auto) ifor(const Xpr& xpr, F&& f) const;
 
-	/** @copydoc IndexInterface::id() */
-	IndexId<0> id() const;
+	    /** @copydoc IndexInterface::formatIsTrivial() */
+	    bool formatIsTrivial() const;
 
-	/** @copydoc IndexInterface::operator*() */
-	MetaType operator*() const;
+	    /** @copydoc IndexInterface::xpr() */
+	    decltype(auto) xpr(const Sptr<RIndex<IndexI,IndexK>>& _this) const;
+
+	    /** Get the current rank. */
+	    int rank() const;
+
+	    /** Get the local index on THIS rank. */
+	    Sptr<IndexI,IndexK> local() const;
+	    //!!!
 	
-	/** @copydoc IndexInterface::dim() */
-	constexpr SizeT dim() const;
+	private:
+	    Sptr<RangeType> mRange; /**< RRange. */
+	    Sptr<IndexI> mJ; /**< Index on the local range of the THIS rank. */
+	    Sptr<IndexK> mK; /**< Multi-index indicating the current rank. */
+	    //!!!
+	};
 
-	/** @copydoc IndexInterface::range() */
-	Sptr<RangeType> range() const;
+	// Factory!!!
 
-	/** @copydoc IndexInterface::stepSize() */
-	template <SizeT I>
-	decltype(auto) stepSize(const IndexId<I>& id) const;
+	/** ****
+	    Range-Wrapper for ranges that are distributed on MPI ranks.
+	    @tparam Range Local range type.
+	*/
+	template <class Range>
+	class RRange : public RangeInterface<RRange<Range>>
+	{
+	public:
+	    typedef RangeBase RB;
+	    typedef RIndex<typename Range::IndexType> IndexType;
+	    typedef typename Range::MetaType MetaType;
 
-	/** @copydoc IndexInterface::stringMeta() */
-	String stringMeta() const;
+	    friend RRangeFactory<Range>;
 
-	/** @copydoc IndexInterface::meta() */
-	MetaType meta() const;
+	    virtual RangePtr sub(SizeT num) const override final;
+	    virtual MArray<RangePtr> sub() const override final;
+	    virtual SizeT size() const override final;
+	    virtual SizeT dim() const override final;
+	    virtual String stringMeta(SizeT pos) const override final;
+	    virtual const TypeInfo& type() const override final;
+	    virtual const TypeInfo& metaType() const override final;
+	    virtual RangePtr extend(const RangePtr& r) const override final;
 
-	/** @copydoc IndexInterface::at() */
-	RIndex& at(const MetaType& metaPos);
+	    /** Get local range. */
+	    Sptr<Range> local() const;
 
-	/** @copydoc IndexInterface::prange() */
-	RangePtr prange(const RIndex<Index>& last) const;
+	    /** Get range of the rank geometry. */
+	    Sptr<YRange> geom() const;
+	    
+	    /** Get meta data for given lexicographic position.
+		@param pos Lexicographic position.
+	    */
+	    const MetaType get(SizeT pos) const;
 
-	/** @copydoc IndexInterface::deepFormat() */
-	auto deepFormat() const;
+	    /** Get lexicographic position according to the given meta data value.
+		@param metaPos Meta data value.
+	    */
+	    SizeT getMeta(const MetaType& metaPos) const;
 
-	/** @copydoc IndexInterface::deepMax() */
-	auto deepMax() const;
+	    /** Get rank from lexicographic meta data position.
+		@param pos Lexicographic meta data position.
+	    */
+	    int getRank(SizeT pos) const;
 
-	/** @copydoc IndexInterface::reformat() */
-	RIndex& reformat(const Vector<SizeT>& f, const Vector<SizeT>& s);
+	protected:
 
-	/** @copydoc IndexInterface::ifor() */
-	template <class Xpr, class F>
-	constexpr decltype(auto) ifor(const Xpr& xpr, F&& f) const;
+	    /** Dafault constructor */
+	    RRange() = default;
 
-	/** @copydoc IndexInterface::formatIsTrivial() */
-	bool formatIsTrivial() const;
+	    RRange(const RRange& in) = delete;
+	    RRange& operator=(const RRange& in) = delete;
 
-	/** @copydoc IndexInterface::xpr() */
-	decltype(auto) xpr(const Sptr<MIndex<Indices...>>& _this) const;
-
-	//!!!
+	    /** Construct from local range and geometry.
+		@param loc Local range.
+		@param geom Rank geometry range.
+	    */
+	    RRange(const Sptr<Range>& loc, const Sptr<YRange>& geom);
 	
-    private:
-	Sptr<RangeType> mRange;
-	Sptr<Index> mLocalI;
-	//!!!
-    };
-
-    // Factory!!!
-
-    /** ****
-	Range-Wrapper for ranges that are distributed on MPI ranks.
-	@tparam Range Local range type.
-     */
-    template <class Range>
-    class RRange : public RangeInterface<RRange<Range>>
-    {
-    public:
-	typedef RangeBase RB;
-	typedef RIndex<typename Range::IndexType> IndexType;
-	typedef typename Range::MetaType MetaType;
-
-	friend RRangeFactory<Range>;
-
-	virtual RangePtr sub(SizeT num) const override final;
-	virtual MArray<RangePtr> sub() const override final;
-	virtual SizeT size() const override final;
-	virtual SizeT dim() const override final;
-	virtual String stringMeta(SizeT pos) const override final;
-	virtual const TypeInfo& type() const override final;
-	virtual const TypeInfo& metaType() const override final;
-	virtual RangePtr extend(const RangePtr& r) const override final;
-
-	/** Get local range. */
-	Sptr<Range> local() const;
+	    Sptr<Range> mLocal; /**< Local range of THIS rank. */
+	    Sptr<YRange> mGeom; /**< Rank geometry range. */
 	
-	/** Get meta data for given lexicographic position.
-	    @param pos Lexicographic position.
-	 */
-	const MetaType get(SizeT pos) const;
+	};
 
-	/** Get lexicographic position according to the given meta data value.
-	    @param metaPos Meta data value.
-	 */
-	SizeT getMeta(const MetaType& metaPos) const;
-
-	/** Get rank from lexicographic meta data position.
-	    @param pos Lexicographic meta data position.
-	 */
-	int getRank(SizeT pos) const;
-
-    protected:
-
-	/** Dafault constructor */
-	RRange() = default;
-
-	RRange(const RRange& in) = delete;
-	RRange& operator=(const RRange& in) = delete;
-
-	/** Construct from local range and geometry.
-	    @param loc Local range.
-	    @param geom Rank geometry range.
-	 */
-	RRange(const Sptr<Range>& loc, const Sptr<YRange>& geom);
+	/** Create RRange from global range and given rank geometry.
+	    @param global Global range.
+	    @param geom Rank geometry.
+	*/
+	template <class GRange>
+	RangePtr rrange(const Sptr<GRange>& global, const Sptr<YRange>& geom);
 	
-	Sptr<Range> mLocal; /**< Local range of THIS rank. */
-	Sptr<YRange> mGeom; /**< Rank geometry range. */
-	
-    };
-
-    /** Create RRange from global range and given rank geometry.
-	@param global Global range.
-	@param geom Rank geometry.
-     */
-    template <class GRange>
-    RangePtr rrange(const Sptr<GRange>& global, const Sptr<YRange>& geom);
-}
+    } // namespace mpi
+} // namespace CNORXZ
 
 #endif