maia::coupling Namespace Reference

Classes
struct	Mapping
	Multi-to-multi mapping class. More...
class	range
	Simple implementation of c++20 range. More...

Functions
template<MInt nDim, class S , class T , class M , class C >
void	setBoundaryForce (S &src, T &tgt, M &mapping, C conversion)
	Setting the boundary force from one surface collector to the other. More...
template<MInt nDim, class S , class T , class M , class C >
void	setBoundaryForceAndTorque (S &src, T &tgt, M &mapping, C conversion)
	Setting the boundary force and torque from one surface collector to the other. More...
template<MInt nDim, class S , class T , class M , class C >
void	setBoundaryVelocity (S &src, T &tgt, M &mapping, C conversion)
	Setting the boundary velocity from one surface collector to the other. More...

Function Documentation

setBoundaryForce()

template<MInt nDim, class S , class T , class M , class C >

void maia::coupling::setBoundaryForce	(	S &	src,
		T &	tgt,
		M &	mapping,
		C	conversion
	)

Looping over all source surfaces (e.g. cells) and apply the forces to all mapped target surfaces (e.g. bodies)

Author

Julian Vorspohl j.vor.nosp@m.spoh.nosp@m.l@aia.nosp@m..rwt.nosp@m.h-aac.nosp@m.hen..nosp@m.de

Template Parameters

nDim	Number of dimensions
S	Source collector type
T	Target collector type
M	Mapping type
C	Conversion factor type

Parameters

[in]	src	Source collector of surfaces
[out]	tgt	Target collector of surfaces
[in]	mapping	Mapping between source and target surfaces
[in]	conversion	Coversion factors between source and target unit system

Definition at line 37 of file surfacecoupling.h.

                                                                {
  tgt.resetForce();
 
  for(MInt srcId = 0; srcId < src.size(); srcId++) {
    std::array<MFloat, nDim> force{};
    for(MInt n = 0; n < nDim; n++) {
      force[n] = src.force(srcId, n) * conversion.force;
    }
 
    for(auto&& tgtId : mapping[srcId]) {
      tgt.addForce(tgtId, force);
    }
  }
}

setBoundaryForceAndTorque()

template<MInt nDim, class S , class T , class M , class C >

void maia::coupling::setBoundaryForceAndTorque	(	S &	src,
		T &	tgt,
		M &	mapping,
		C	conversion
	)

Looping over all source surfaces (e.g. cells) and apply the forces to all mapped target surfaces (e.g. bodies)

Author

Julian Vorspohl j.vor.nosp@m.spoh.nosp@m.l@aia.nosp@m..rwt.nosp@m.h-aac.nosp@m.hen..nosp@m.de

Template Parameters

nDim	Number of dimensions
S	Source collector type
T	Target collector type
M	Mapping type
C	Conversion factor type

Parameters

[in]	src	Source collector of surfaces
[out]	tgt	Target collector of surfaces
[in]	mapping	Mapping between source and target surfaces
[in]	conversion	Coversion factors between source and target unit system

Definition at line 71 of file surfacecoupling.h.

                                                                         {
  static constexpr MInt nRot = (nDim == 3) ? 3 : 1;
 
  tgt.resetForce();
  tgt.resetTorque();
 
  for(MInt srcId = 0; srcId < src.size(); srcId++) {
    for(MInt j = 0; j < src.noForces(); j++) {
      std::array<MFloat, nDim> force{};
      for(MInt n = 0; n < nDim; n++) {
        force[n] = src.force(srcId, j, n) * conversion.force;
      }
 
      for(auto&& tgtId : mapping[srcId]) {
        tgt.addForce(tgtId, force);
 
        std::array<MFloat, nDim> r{};
        for(MInt n = 0; n < nDim; n++) {
          r[n] = (src.surfaceCenter(srcId, j, n) - tgt.a_bodyCenter(tgtId, n)) * conversion.length;
        }
 
        std::array<MFloat, nRot> torque{};
        if constexpr(nDim == 3) {
          torque = maia::math::cross(force, r);
        } else if constexpr(nDim == 2) {
          torque[0] = force[0] * r[1] - force[1] * r[0];
        }
 
        tgt.addTorque(tgtId, torque);
      }
    }
  }
}

setBoundaryVelocity()

template<MInt nDim, class S , class T , class M , class C >

void maia::coupling::setBoundaryVelocity	(	S &	src,
		T &	tgt,
		M &	mapping,
		C	conversion
	)

Looping over all source surfaces (e.g. cells) and apply the forces to all mapped target surfaces (e.g. bodies)

Author

Julian Vorspohl j.vor.nosp@m.spoh.nosp@m.l@aia.nosp@m..rwt.nosp@m.h-aac.nosp@m.hen..nosp@m.de

Template Parameters

nDim	Number of dimensions
S	Source collector type
T	Target collector type
M	Mapping type
C	Conversion factor type

Parameters

[in]	src	Source collector of surfaces
[out]	tgt	Target collector of surfaces
[in]	mapping	Mapping between source and target surfaces
[in]	conversion	Coversion factors between source and target unit system

Definition at line 124 of file surfacecoupling.h.

                                                                   {
  static constexpr MInt nRot = (nDim == 3) ? 3 : 1;
 
  if(mapping.size() == 0) {
    return;
  }
 
  for(MInt srcId = 0; srcId < src.size(); srcId++) {
    std::array<MFloat, nDim> velocity{};
    src.getVelocity(srcId, velocity);
    for(MInt n = 0; n < nDim; n++) {
      velocity[n] *= conversion.velocity;
    }
 
    std::array<MFloat, nRot> angularVelocity{};
    src.getAngularVelocity(srcId, angularVelocity);
    for(MInt n = 0; n < nRot; n++) {
      angularVelocity[n] *= conversion.angularVelocity;
    }
 
    for(auto&& tgtId : mapping[srcId]) {
      std::array<MFloat, nDim> r{};
      for(MInt n = 0; n < nDim; n++) {
        r[n] = (tgt.cellCenter(tgtId, n) - src.a_bodyCenter(srcId, n)) * conversion.length;
      }
      std::array<MFloat, nDim> rotationalVelocity{};
      IF_CONSTEXPR(nDim == 3) { rotationalVelocity = maia::math::cross(r, angularVelocity); }
      else IF_CONSTEXPR(nDim == 2) {
        rotationalVelocity[0] = angularVelocity[0] * r[0];
        rotationalVelocity[1] = angularVelocity[0] * r[1];
      }
 
      tgt.setVelocity(tgtId, velocity);
      tgt.addVelocity(tgtId, rotationalVelocity);
    }
  }
}