PropertyConverter.h

Go to the documentation of this file.

/* Copyright 2019 Kristofer Björnson
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef COM_DAFER45_TBTK_PROPERTY_CONVERTER
#define COM_DAFER45_TBTK_PROPERTY_CONVERTER

#include "TBTK/AnnotatedArray.h"
#include "TBTK/Property/AbstractProperty.h"
#include "TBTK/TBTKMacros.h"

namespace TBTK{

class PropertyConverter{
public:
    template<typename DataType>
    static AnnotatedArray<DataType, Subindex> convert(
        const Property::AbstractProperty<DataType> &abstractProperty
    );

    template<typename DataType>
    static AnnotatedArray<DataType, Subindex> convert(
        const Property::AbstractProperty<DataType> &abstractProperty,
        const Index &pattern
    );
};

template<typename DataType>
AnnotatedArray<DataType, Subindex> PropertyConverter::convert(
    const Property::AbstractProperty<DataType> &abstractProperty
){
    IndexDescriptor::Format format
        = abstractProperty.getIndexDescriptor().getFormat();

    switch(format){
    case IndexDescriptor::Format::None:
    {
        Array<DataType> array({abstractProperty.getBlockSize()});
        std::vector<std::vector<Subindex>> axis(1);
        for(unsigned int n = 0; n < abstractProperty.getBlockSize(); n++){
            array[{n}] = abstractProperty(n);
            axis[0].push_back(n);
        }
        return AnnotatedArray<DataType, Subindex>(array, axis);
    }
    case IndexDescriptor::Format::Ranges:
    {
        std::vector<int> ranges
            = abstractProperty.getIndexDescriptor().getRanges();
        if(abstractProperty.getBlockSize() != 1)
            ranges.push_back(abstractProperty.getBlockSize());
        std::vector<unsigned int> rangesUnsignedInt;
        for(unsigned int n = 0; n < ranges.size(); n++)
            rangesUnsignedInt.push_back(ranges[n]);

        Array<DataType> array = Array<DataType>::create(rangesUnsignedInt);
        const std::vector<DataType> &data = abstractProperty.getData();
        for(unsigned int n = 0; n < abstractProperty.getSize(); n++)
            array[n] = data[n];

        std::vector<std::vector<Subindex>> axes(ranges.size());
        for(unsigned int n = 0; n < ranges.size(); n++)
            for(unsigned int c = 0; c < (unsigned int)ranges[n]; c++)
                axes[n].push_back(c);

        return AnnotatedArray<DataType, Subindex>(array, axes);
    }
    default:
        TBTKExit(
            "PropertyConverter::convert()",
            "Unsupported format. Only IndexDescriptor::Format::None and"
            << " IndexDescriptor::Format::Ranges supported.",
            ""
        );
    }
}

template<typename DataType>
AnnotatedArray<DataType, Subindex> PropertyConverter::convert(
    const Property::AbstractProperty<DataType> &abstractProperty,
    const Index &pattern
){
    IndexDescriptor::Format format
        = abstractProperty.getIndexDescriptor().getFormat();

    switch(format){
    case IndexDescriptor::Format::Custom:
    {
        std::vector<unsigned int> wildcardPositions;
        for(unsigned int n = 0; n < pattern.getSize(); n++)
            if(pattern[n].isWildcard())
                wildcardPositions.push_back(n);

        const IndexTree &indexTree
            = abstractProperty.getIndexDescriptor().getIndexTree();
        std::vector<Index> indexList = indexTree.getIndexList(pattern);

        std::vector<Subindex> minSubindices;
        std::vector<Subindex> maxSubindices;
        for(unsigned int n = 0; n < wildcardPositions.size(); n++){
            Subindex min = indexList[0][wildcardPositions[n]];
            Subindex max = indexList[0][wildcardPositions[n]];
            for(unsigned int c = 1; c < indexList.size(); c++){
                Subindex subindex
                    = indexList[c][wildcardPositions[n]];
                if(min > subindex)
                    min = subindex;
                if(max < subindex)
                    max = subindex;
            }
            minSubindices.push_back(min);
            maxSubindices.push_back(max);
        }
        if(abstractProperty.getBlockSize() > 1){
            minSubindices.push_back(0);
            maxSubindices.push_back(
                abstractProperty.getBlockSize() - 1
            );
        }

        std::vector<unsigned int> ranges;
        for(unsigned int n = 0; n < minSubindices.size(); n++){
            ranges.push_back(
                maxSubindices[n] - minSubindices[n] + 1
            );
        }
        Array<DataType> array = Array<DataType>::create(
            ranges,
            DataType(0)
        );
        for(unsigned int n = 0; n < indexList.size(); n++){
            const Index index = indexList[n];
            std::vector<unsigned int> arrayIndices;
            for(unsigned int c = 0; c < wildcardPositions.size(); c++){
                arrayIndices.push_back(
                    index[wildcardPositions[c]]
                    - minSubindices[c]
                );
            }
            if(abstractProperty.getBlockSize() > 1){
                for(
                    unsigned int c = 0;
                    c < abstractProperty.getBlockSize();
                    c++
                ){
                    std::vector<
                        unsigned int
                    > blockExtendedArrayIndices
                        = arrayIndices;
                    blockExtendedArrayIndices.push_back(c);

                    array[blockExtendedArrayIndices]
                        = abstractProperty(index, c);
                }
            }
            else{
                array[arrayIndices] = abstractProperty(index);
            }
        }

        std::vector<std::vector<Subindex>> axes(ranges.size());
        for(
            unsigned int n = 0;
            n < ranges.size();
            n++
        ){
            for(
                unsigned int c = 0;
                c < (unsigned int)ranges[n];
                c++
            ){
                axes[n].push_back(minSubindices[n] + c);
            }
        }

        return AnnotatedArray<DataType, Subindex>(array, axes);
    }
    default:
        TBTKExit(
            "PropertyConverter::convert()",
            "Unsupported format. Only IndexDescriptor::Format::None and"
            << " IndexDescriptor::Format::Ranges supported.",
            ""
        );
    }
}

}; //End of namesapce TBTK

#endif