aggregatedTypeVectorAccessWrapper.hpp

/*
 * CoDiPack, a Code Differentiation Package
 *
 * Copyright (C) 2015-2025 Chair for Scientific Computing (SciComp), University of Kaiserslautern-Landau
 * Homepage: http://scicomp.rptu.de
 * Contact:  Prof. Nicolas R. Gauger (codi@scicomp.uni-kl.de)
 *
 * Lead developers: Max Sagebaum, Johannes Blühdorn (SciComp, University of Kaiserslautern-Landau)
 *
 * This file is part of CoDiPack (http://scicomp.rptu.de/software/codi).
 *
 * CoDiPack is free software: you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * CoDiPack is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty
 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * See the GNU General Public License for more details.
 * You should have received a copy of the GNU
 * General Public License along with CoDiPack.
 * If not, see <http://www.gnu.org/licenses/>.
 *
 * For other licensing options please contact us.
 *
 * Authors:
 *  - SciComp, University of Kaiserslautern-Landau:
 *    - Max Sagebaum
 *    - Johannes Blühdorn
 *    - Former members:
 *      - Tim Albring
 */
#pragma once
 
#include <complex>
#include <vector>
 
#include "../../config.h"
#include "../../expressions/aggregate/aggregatedActiveType.hpp"
#include "../../expressions/lhsExpressionInterface.hpp"
#include "../../misc/macros.hpp"
#include "../../tapes/misc/vectorAccessInterface.hpp"
#include "../../traits/computationTraits.hpp"
#include "../../traits/expressionTraits.hpp"
#include "../../traits/realTraits.hpp"

namespace codi {

  template<typename T_Type, typename = void>
  struct AggregatedTypeVectorAccessWrapper : public VectorAccessInterface<CODI_ANY, CODI_ANY> {
      CODI_STATIC_ASSERT(false && std::is_void<T_Type>::value,
                         "Instantiation of unspecialized AggregatedTypeVectorAccessWrapper.");
 
      using Type = CODI_DD(T_Type, CODI_ANY);  
  };

  template<typename T_Type>
  struct AggregatedTypeVectorAccessWrapper<T_Type, RealTraits::EnableIfAggregatedActiveType<T_Type>> {
    public:
 
      using Type = CODI_DD(
          T_Type,
          CODI_T(AggregatedActiveType<double, CODI_ANY, CODI_ANY>));  
      using InnerType = typename Type::InnerActiveType;               
      static int constexpr Elements = Type::Elements;                 

      using InnerInterface = VectorAccessInterface<typename InnerType::Real, typename InnerType::Identifier>;
 
      using Real = typename RealTraits::DataExtraction<T_Type>::Real;  
      using Identifier =
          typename RealTraits::DataExtraction<T_Type>::Identifier;  
 
      using Traits = RealTraits::AggregatedTypeTraits<Real>;  
 
      InnerInterface& innerInterface;  
      int lhsOffset;  
 
      std::vector<Real> buffer;  

      CODI_INLINE AggregatedTypeVectorAccessWrapper(InnerInterface* innerInterface)
          : innerInterface(*innerInterface), lhsOffset(0), buffer(innerInterface->getVectorSize()) {}
 
      /*******************************************************************************/

      CODI_INLINE size_t getVectorSize() const {
        return innerInterface.getVectorSize();
      }

      CODI_INLINE bool isLhsZero() const {
        bool isZero = true;
 
        static_for<Elements>([&](auto i) CODI_LAMBDA_INLINE {
          innerInterface.setActiveVariableForIndirectAccess(lhsOffset + i.value);
          isZero &= innerInterface.isLhsZero();
        });
 
        return isZero;
      }
 
      /*******************************************************************************/

      CODI_INLINE void setLhsAdjoint(Identifier const& index) {
        static_for<Elements>([&](auto i) CODI_LAMBDA_INLINE {
          innerInterface.setActiveVariableForIndirectAccess(lhsOffset + i.value);
          innerInterface.setLhsAdjoint(index[i.value]);
        });
      }

      CODI_INLINE void updateAdjointWithLhs(Identifier const& index, Real const& jacobian) {
        static_for<Elements>([&](auto i) CODI_LAMBDA_INLINE {
          innerInterface.setActiveVariableForIndirectAccess(lhsOffset + i.value);
          innerInterface.updateAdjointWithLhs(index[i.value], Traits::template arrayAccess<i.value>(jacobian));
        });
      }
 
      /*******************************************************************************/

      CODI_INLINE void setLhsTangent(Identifier const& index) {
        static_for<Elements>([&](auto i) CODI_LAMBDA_INLINE {
          innerInterface.setActiveVariableForIndirectAccess(lhsOffset + i.value);
          innerInterface.setLhsTangent(index[i.value]);
        });
      }

      CODI_INLINE void updateTangentWithLhs(Identifier const& index, Real const& jacobian) {
        static_for<Elements>([&](auto i) CODI_LAMBDA_INLINE {
          innerInterface.setActiveVariableForIndirectAccess(lhsOffset + i.value);
          innerInterface.updateTangentWithLhs(index[i.value], Traits::template arrayAccess<i.value>(jacobian));
        });
      }
 
      /*******************************************************************************/

      CODI_INLINE void setActiveVariableForIndirectAccess(size_t pos) {
        lhsOffset = pos * Elements;
      }
 
      /*******************************************************************************/

      CODI_INLINE void resetAdjoint(Identifier const& index, size_t dim) {
        static_for<Elements>([&](auto i) CODI_LAMBDA_INLINE {
          innerInterface.resetAdjoint(index[i.value], dim);
        });
      }

      CODI_INLINE void resetAdjointVec(Identifier const& index) {
        static_for<Elements>([&](auto i) CODI_LAMBDA_INLINE {
          innerInterface.resetAdjointVec(index[i.value]);
        });
      }

      CODI_INLINE Real getAdjoint(Identifier const& index, size_t dim) {
        Real adjoint{};
 
        static_for<Elements>([&](auto i) CODI_LAMBDA_INLINE {
          Traits::template arrayAccess<i.value>(adjoint) = innerInterface.getAdjoint(index[i.value], dim);
        });
 
        return adjoint;
      }

      CODI_INLINE void getAdjointVec(Identifier const& index, Real* const vec) {
        for (size_t curDim = 0; curDim < innerInterface.getVectorSize(); curDim += 1) {
          vec[curDim] = this->getAdjoint(index, curDim);
        }
      }

      Real const* getAdjointVec(Identifier const& index) {
        getAdjointVec(index, buffer.data());
        return buffer.data();
      }

      CODI_INLINE void updateAdjoint(Identifier const& index, size_t dim, Real const& adjoint) {
        static_for<Elements>([&](auto i) CODI_LAMBDA_INLINE {
          innerInterface.updateAdjoint(index[i.value], dim, Traits::template arrayAccess<i.value>(adjoint));
        });
      }

      CODI_INLINE void updateAdjointVec(Identifier const& index, Real const* const vec) {
        for (size_t curDim = 0; curDim < innerInterface.getVectorSize(); curDim += 1) {
          this->updateAdjoint(index, curDim, vec[curDim]);
        }
      }
 
      /*******************************************************************************/

      CODI_INLINE bool hasPrimals() {
        return innerInterface.hasPrimals();
      }

      CODI_INLINE void setPrimal(Identifier const& index, Real const& primal) {
        static_for<Elements>([&](auto i) CODI_LAMBDA_INLINE {
          innerInterface.setPrimal(index[i.value], Traits::template arrayAccess<i.value>(primal));
        });
      }

      CODI_INLINE Real getPrimal(Identifier const& index) {
        Real primal{};
 
        static_for<Elements>([&](auto i) CODI_LAMBDA_INLINE {
          Traits::template arrayAccess<i.value>(primal) = innerInterface.getPrimal(index[i.value]);
        });
 
        return primal;
      }
  };

  template<typename T_Type, typename = void>
  struct AggregatedTypeVectorAccessWrapperFactory {
    public:
      using Type = CODI_DD(T_Type, CODI_ANY);  
 
      using RType = AggregatedTypeVectorAccessWrapper<Type>;  

      template<typename Real, typename Identifier>
      static RType* create(VectorAccessInterface<Real, Identifier>* access) {
        return new RType(access);
      }

      static void destroy(RType* access) {
        delete access;
      }
  };
 
#ifndef DOXYGEN_DISABLE
  template<typename T_Type>
  struct AggregatedTypeVectorAccessWrapperFactory<T_Type, ExpressionTraits::EnableIfLhsExpression<T_Type>> {
    public:
      using Type = CODI_DD(T_Type, CODI_DEFAULT_LHS_EXPRESSION);  
 
      using RType = VectorAccessInterface<typename Type::Real, typename Type::Identifier>;

      static RType* create(RType* access) {
        return access;
      }

      static void destroy(RType* access) {
        CODI_UNUSED(access);
 
        // Do nothing
      }
  };
#endif
}