Field.h

/*
 * (C) Copyright 2013 ECMWF.
 *
 * This software is licensed under the terms of the Apache Licence Version 2.0
 * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
 * In applying this licence, ECMWF does not waive the privileges and immunities
 * granted to it by virtue of its status as an intergovernmental organisation
 * nor does it submit to any jurisdiction.
 */


#pragma once

#include <iosfwd>
#include <string>

#include "atlas/array/ArrayShape.h"
#include "atlas/array/DataType.h"
#include "atlas/array_fwd.h"
#include "atlas/library/config.h"
#include "atlas/util/ObjectHandle.h"

namespace eckit {
class Parametrisation;
}
namespace atlas {
namespace field {
class FieldImpl;
}
}  // namespace atlas
namespace atlas {
namespace util {
class Metadata;
}
}  // namespace atlas
namespace atlas {
class FunctionSpace;
}

namespace atlas {

class Field : DOXYGEN_HIDE( public util::ObjectHandle<field::FieldImpl> ) {
public:
    using Handle::Handle;
    Field() = default;

    Field( const eckit::Parametrisation& );

    Field( const std::string& name, array::DataType, const array::ArrayShape& = array::ArrayShape() );

    Field( const std::string& name, array::DataType, array::ArraySpec&& );

    Field( const std::string& name, array::Array* );

    template <typename DATATYPE>
    Field( const std::string& name, DATATYPE* data, const array::ArraySpec& );

    template <typename DATATYPE>
    Field( const std::string& name, DATATYPE* data, const array::ArrayShape& );

    // -- Conversion

    operator const array::Array&() const;
    operator array::Array&();

    const array::Array& array() const;
    array::Array& array();

    bool valid() const { return get() != nullptr; }

    // -- Accessors

    void* storage();

    array::DataType datatype() const;

    const std::string& name() const;

    void rename( const std::string& name );

    const util::Metadata& metadata() const;
    util::Metadata& metadata();

    void resize( const array::ArrayShape& shape );

    void insert( idx_t idx1, idx_t size1 );

    const std::vector<int>& shapef() const;

    const std::vector<int>& stridesf() const;

    const array::ArrayShape& shape() const;

    const array::ArrayStrides& strides() const;

    idx_t shape( idx_t i ) const;

    idx_t stride( idx_t i ) const;

    size_t size() const;

    idx_t rank() const;

    size_t bytes() const;

    bool contiguous() const;

    friend std::ostream& operator<<( std::ostream& os, const Field& v );

    void dump( std::ostream& os ) const;

    void set_levels( idx_t n );
    idx_t levels() const;

    void set_variables( idx_t n );
    idx_t variables() const;

    void set_functionspace( const FunctionSpace& functionspace );
    const FunctionSpace& functionspace() const;

    size_t footprint() const;

    bool dirty() const;

    void set_dirty( bool = true ) const;

    void haloExchange( bool on_device = false ) const;
    void adjointHaloExchange( bool on_device = false ) const;

    // -- Methods related to host-device synchronisation
    void updateHost() const;
    void updateDevice() const;
    void syncHostDevice() const;
    bool hostNeedsUpdate() const;
    bool deviceNeedsUpdate() const;
    void reactivateDeviceWriteViews() const;
    void reactivateHostWriteViews() const;
};

extern template Field::Field( const std::string&, float*, const array::ArraySpec& );
extern template Field::Field( const std::string&, float*, const array::ArrayShape& );
extern template Field::Field( const std::string&, double*, const array::ArraySpec& );
extern template Field::Field( const std::string&, double*, const array::ArrayShape& );
extern template Field::Field( const std::string&, long*, const array::ArraySpec& );
extern template Field::Field( const std::string&, long*, const array::ArrayShape& );
extern template Field::Field( const std::string&, int*, const array::ArraySpec& );
extern template Field::Field( const std::string&, int*, const array::ArrayShape& );

//------------------------------------------------------------------------------------------------------

}  // namespace atlas