UniformCartesianArray.hpp

#ifndef __FIBER__UNIFORMCARTESIANARRAY_HPP
#define __FIBER__UNIFORMCARTESIANARRAY_HPP
 
#ifndef DONT_USE_PRAGMA_ONCE
#pragma once
#endif
 
#include "DirectProductArray.hpp"
#include <eagle/PhysicalSpace.hpp>
#include <aerie/BoundingBox.hpp>
 
namespace Fiber
{
 
//extern template class FIELD_API  LinearDirectProductMemArray<Eagle::point3, Eagle::tvector3>;
//extern template class  LinearDirectProductMemArray<Eagle::point3, Eagle::tvector3>;
 
class   FIELD_API       UniformCartesianArray : public  LinearDirectProductMemArray<Eagle::point3, Eagle::tvector3>
{
 
static  Eagle::point3 DeltaPoint(const Eagle::tvector3&what, const MultiIndex<3>&divisor)
        {
        Eagle::point3 retval;
                for(int i=0; i<3; i++)
                {
                        if (divisor[i]<2)
                        {
//
// exceptions are not good in constructors.
// better use this as default.
//                              if (divisor[i]<1)
//                                      throw Exception( i, divisor[i]);
 
                                retval[i] = what[i];
                        }
                        else
                                retval[i] = what[i] / (divisor[i]-1);
                }
                return retval;
        }
 
public:
 
static  Eagle::tvector3 idiv(const Eagle::tvector3&what, const MultiIndex<3>&divisor)
        {
        Eagle::tvector3 retval;
                for(int i=0; i<3; i++)
                {
                        if (divisor[i]<2)
                        {
                                retval[i] = what[i];
                        }
                        else
                                retval[i] = what[i] / (divisor[i]-1);
                }
                return retval;
        }
 
public:
 
        typedef LinearDirectProductMemArray<Eagle::point3, Eagle::tvector3> UniformCartesianArrayBase_t;
 
        UniformCartesianArray(const Eagle::point3&start, const MultiIndex<3>&dims,
                              const Eagle::point3&end,
                              const MemBase::Creator_t&C = MemCore::NullPtr() );
 
        UniformCartesianArray(const Eagle::BoundingBox&BBox, const MultiIndex<3>&dims,
                              const MemBase::Creator_t&C = MemCore::NullPtr() );
 
 
        UniformCartesianArray(const MultiIndex<3>&dims, const Eagle::point3&start,
                              const Eagle::tvector3&delta, const MemBase::Creator_t&C = MemCore::NullPtr() );
 
 
        UniformCartesianArray(const UniformCartesianArray&UCA, const MemBase::Creator_t&C = MemCore::NullPtr() )
        : MemBase(FiberType<Eagle::point3>::getFiberType()->getFiberTypeIndex(), C)
        , LinearDirectProductMemArray<Eagle::point3, Eagle::tvector3>(UCA)
        {}
 
        RefPtr<MemBase> copy(const MemBase::Creator_t&C = nullptr) const override
        {
                return new UniformCartesianArray(*this, C);
        }
 
        RefPtr<Eagle::BoundingBox>      getBoundingBox() const;
 
        Eagle::tvector3 cell_diagonal() const
        {
                return Delta();
        }
 
protected:
        ~UniformCartesianArray();
};
 
 
typedef DirectProductMemArray<Eagle::point3, ExplicitCoordinateAxisArray> RectilinearCartesianArray;
 
 
} // namespace Fiber
 
#endif // __FIBER__UNIFORMCARTESIANARRAY_HPP