Surface data sampling class. Records all sampling variables on all surface elements and outputs additional geometric information for further postprocessing the data, e.g., using the Ffowcs Williams-Hawkings method for acoustic far-field predictions. More...

#include <samplingdata.h>

Inheritance diagram for SurfaceData< nDim, SolverType >:

[legend]

Collaboration diagram for SurfaceData< nDim, SolverType >:

[legend]

Public Types
using	Base = SamplingData< nDim, SolverType >

Public Member Functions
	SurfaceData (SolverType &solver_)

virtual	~SurfaceData ()

void	saveGeomInfo (const MString inputFileName, const MInt fileNo, MFloat *coordinates)
	Store geometric information for all elements of a surface. More...

MInt	loadInputFile (const MString inputFileName, const MInt fileNo, std::vector< MFloat > &coordinates) override
	Load an input file for the surface data sampling feature. More...

MString	getBaseName () const override
	Return base name of derived class, e.g. used for naming properties and output file names. More...

MBool	isMpiRoot () const

MPI_Comm	mpiComm () const

SolverType &	solver ()
	Return reference to solver. More...

const SolverType &	solver () const

MInt	solverId () const

Public Member Functions inherited from SamplingData< nDim, SolverType >
	SamplingData (SolverType &solver)

void	init ()

void	save (MBool finalTimestep)

void	setInputOutputProperties ()

MBool	enabled () const

virtual MInt	loadInputFile (const MString NotUsed(inputFileName), const MInt NotUsed(fileNo), std::vector< MFloat > &NotUsed(coordinates))

virtual MString	getBaseName () const
	Return base name of derived class, e.g. used for naming properties and output file names. More...

Public Attributes
MBool	m_enabled

std::vector< SamplingDataSeries >	m_timeSeries
	Holds all properties and buffers for each input file. More...

Private Attributes
GeometryXD< nDim >::type *	m_geometry = nullptr

Additional Inherited Members
Protected Member Functions inherited from SamplingData< nDim, SolverType >
void	init (SamplingDataSeries &timeSeries)

void	save (SamplingDataSeries &timeSeries, MBool finalTimeStep)
	Saves sampling data Saves all states of conservative variables at specified points. Also writes sampling data files in specified intervals. More...

virtual MBool	hasInputDataFile (const MInt fileNo) const
	Check if an input file exists, might be overwritten in derived class if points are generated. More...

virtual MBool	generatePoints () const
	Default behaviour for point generation which can be overwritten in derived class. More...

virtual MInt	noSamplingPoints (const MInt NotUsed(fileNo))
	Return the number of sampling points which are generated by the derived class (no input file) More...

virtual void	getSamplingPoint (const MInt NotUsed(fileNo), const MInt NotUsed(pointId), MFloat *const NotUsed(coordinates))
	Return the coordinates of the sampling point with the given id when generating points. More...

void	indexXD (const MInt index, const MInt const nPoints, MInt indexXD)
	Convert 1D index into 2D/3D index. More...

void	saveSamplingPointCoordinates (SamplingDataSeries &timeSeries)
	Save point coordinates of time series. More...

virtual void	readAdditionalProperties (const MInt NotUsed(fileNo))
	Read additional properties which are required by the derived class. More...

MInt	solverId () const

MBool	isMpiRoot () const

MPI_Comm	mpiComm () const

MInt	noVars () const
	Return total number of sampling variables. More...

MString	getFileBaseName () const
	Return base name of files for used sampling feature. More...

SolverType &	solver ()
	Return reference to solver. More...

const SolverType &	solver () const

Protected Attributes inherited from SamplingData< nDim, SolverType >
MBool	m_enabled = false

MBool	m_interpolatePointData

std::vector< SamplingDataSeries >	m_timeSeries {}
	Holds all properties and buffers for each input file. More...

std::vector< MInt >	m_solverSamplingVarIds {}
	List of sampling variables. More...

std::vector< MInt >	m_noSolverSamplingVars {}
	Number of variables for each sampling variable. More...

std::vector< std::vector< MString > >	m_solverSamplingVarNames {}
	List of variable names for each sampling variable. More...

Detailed Description

template<MInt nDim, class SolverType>
class SurfaceData< nDim, SolverType >

Definition at line 190 of file samplingdata.h.

Member Typedef Documentation

◆ Base

template<MInt nDim, class SolverType >

using SurfaceData< nDim, SolverType >::Base = SamplingData<nDim, SolverType>

Definition at line 192 of file samplingdata.h.

Constructor & Destructor Documentation

◆ SurfaceData()

template<MInt nDim, class SolverType >

SurfaceData< nDim, SolverType >::SurfaceData ( SolverType & solver_ )

inline

Definition at line 202 of file samplingdata.h.

202: SamplingData<nDim, SolverType>(solver_) {}

SamplingData

This base class is responsible for the sampling data feature that provides the required general metho...

Definition: samplingdata.h:35

◆ ~SurfaceData()

template<MInt nDim, class SolverType >

SurfaceData< nDim, SolverType >::~SurfaceData

virtual

Definition at line 1091 of file samplingdata.h.

                                            {
  // Free geometry object if existing
  if(m_geometry != nullptr) {
    // TODO labels:PP,IO fix deallocation
    // delete m_geometry;
  }
}

Member Function Documentation

◆ getBaseName()

template<MInt nDim, class SolverType >

MString SurfaceData< nDim, SolverType >::getBaseName ( ) const

inlineoverridevirtual

Reimplemented from SamplingData< nDim, SolverType >.

Definition at line 210 of file samplingdata.h.

210{ return "surface"; }

◆ isMpiRoot()

template<MInt nDim, class SolverType >

MBool SamplingData< nDim, SolverType >::isMpiRoot ( ) const

inline

Definition at line 119 of file samplingdata.h.

119{ return m_solver.domainId() == 0; }

SamplingData::m_solver

SolverType & m_solver

Definition: samplingdata.h:150

◆ loadInputFile()

template<MInt nDim, class SolverType >

MInt SurfaceData< nDim, SolverType >::loadInputFile	(	const MString	inputFileName,
		const MInt	fileNo,
		std::vector< MFloat > &	coordinates
	)

override

The surface is created as an geometry object. For all surface elements that make up a surface in 2D or 3D the centroid is computed in which the sampling variables are determined. Additional geometric information on the surface elements is stored in a separated data file.

Definition at line 1106 of file samplingdata.h.

                                                                                  {
  TRACE();
  if(!isMpiRoot()) {
    TERMM(1, "SurfaceData::loadInputFile() should only be called by mpi root process!");
  }
 
  // Create geometry object
  auto geometry = new typename GeometryXD<nDim>::type(0, inputFileName, MPI_COMM_SELF);
  // Store pointer in class member variable
  m_geometry = geometry;
 
  // Determine number of geometry/surface elements
  MInt noElements = geometry->GetNoElements();
  coordinates.resize(nDim * noElements);
 
  std::array<MFloat, nDim * nDim> vertex;
 
  // Compute element centroids and store in coordinates
  for(MInt i = 0; i < noElements; i++) {
    geometry->elements[i].getVertices(&vertex[0]);
    geometry->elements[i].calcCentroid(&vertex[0], &coordinates[i * nDim]);
  }
 
  // Write specific data for all elements into an output file
  saveGeomInfo(inputFileName, fileNo, &coordinates[0]);
 
  return noElements;
}

◆ mpiComm()

template<MInt nDim, class SolverType >

MPI_Comm SamplingData< nDim, SolverType >::mpiComm ( ) const

inline

Definition at line 120 of file samplingdata.h.

120{ return m_solver.mpiComm(); }

◆ saveGeomInfo()

template<MInt nDim, class SysEqn >

void SurfaceData< nDim, SysEqn >::saveGeomInfo	(	const MString	inputFileName,
		const MInt	fileNo,
		MFloat *	coordinates
	)

This function calculates and saves specific information of 2D and 3D elements that make up a surface: vertices, length/surface area, centroids and surface normal vectors.

The center of the whole geometry is calculated for the determination of the outer surface normal vectors. There is also the option to manually set a geometric center in the property files, e.g., for the case of a line/plane to set a point inside the whole geometry given by multiple surfaces since the geometric center is on the line/plane itself and the direction of the normal vector cannot be determined. Note: this will only work for convex geometries, to make this work for general geometries the user could specify a set of points inside the geometry from which the nearest one is used for a surface element to determine the outer normal vector.

Definition at line 1152 of file samplingdata.h.

                                                                                                                {
  TRACE();
  using namespace maia::parallel_io;
 
  const MInt noElements = m_geometry->GetNoElements();
  // Define output file
  std::ostringstream fileName;
  fileName << solver().outputDir() << "surface_geometryInfo_" << fileNo << ParallelIo::fileExt();
 
  ParallelIo file(fileName.str(), PIO_REPLACE, MPI_COMM_SELF);
  file.setAttribute(inputFileName, "inputFileName");
 
  // Get vertices of an element and calculate length/surface of element
  std::vector<MFloat> vertices(noElements * nDim * nDim);
  std::vector<MFloat> geomMeasures(noElements);
  std::vector<MFloat> normalVecs(noElements * nDim);
 
  MFloat geomCenter[3]{};
 
  // Check if geometry center is defined by user
  if(Context::propertyExists("surfaceDataGeometryCenter_" + std::to_string(fileNo), solverId())) {
    for(MInt i = 0; i < nDim; i++) {
      geomCenter[i] =
          Context::getSolverProperty<MFloat>("surfaceDataGeometryCenter_" + std::to_string(fileNo), solverId(), AT_, i);
    }
  } else {
    // Determine geometry center as average of all element centroids
    for(MInt i = 0; i < noElements; i++) {
      for(MInt dim = 0; dim < nDim; dim++) {
        geomCenter[dim] += coordinates[i * nDim + dim];
      }
    }
    for(MInt dim = 0; dim < nDim; dim++) {
      geomCenter[dim] /= static_cast<MFloat>(noElements);
    }
  }
 
  m_log << "Surface geometry info: geomCenter =";
  for(MInt dim = 0; dim < nDim; dim++) {
    m_log << " " << geomCenter[dim];
  }
  m_log << std::endl;
 
  MInt counter = 0;
  for(MInt i = 0; i < noElements; i++) {
    for(MInt j = 0; j < nDim; j++) {
      for(MInt k = 0; k < nDim; k++) {
        vertices[counter] = m_geometry->elements[i].m_vertices[j][k];
        counter++;
      }
    }
 
    auto& element = m_geometry->elements[i];
    // Calc surface area/length of every element
    IF_CONSTEXPR(nDim == 3) {
      // Define two vectors for triangular surface in 3D
      const MFloat v12_x = element.m_vertices[0][0] - element.m_vertices[1][0];
      const MFloat v12_y = element.m_vertices[0][1] - element.m_vertices[1][1];
      const MFloat v12_z = element.m_vertices[0][2] - element.m_vertices[1][2];
      const MFloat v13_x = element.m_vertices[0][0] - element.m_vertices[2][0];
      const MFloat v13_y = element.m_vertices[0][1] - element.m_vertices[2][1];
      const MFloat v13_z = element.m_vertices[0][2] - element.m_vertices[2][2];
 
      // Cross product
      const MFloat v_x = v12_y * v13_z - v12_z * v13_y;
      const MFloat v_y = v12_z * v13_x - v12_x * v13_z;
      const MFloat v_z = v12_x * v13_y - v12_y * v13_x;
      // Surface area is 1/2 the length of the cross product
      geomMeasures[i] = 0.5 * sqrt(pow(v_x, 2) + pow(v_y, 2) + pow(v_z, 2));
    }
    else {
      const MFloat p1_x = element.m_vertices[0][0];
      const MFloat p2_x = element.m_vertices[1][0];
      const MFloat p1_y = element.m_vertices[0][1];
      const MFloat p2_y = element.m_vertices[1][1];
      // Element length
      geomMeasures[i] = sqrt(pow(p1_x - p2_x, 2) + pow(p1_y - p2_y, 2));
    }
 
    std::array<MFloat, nDim * nDim> vertex;
    m_geometry->elements[i].getVertices(&vertex[0]);
 
    // Calculate surface normal vector
    m_geometry->elements[i].calcNormal(&vertex[0], &normalVecs[i * nDim]);
 
    // Compute dot product of surface normal vector and the vector from the geometric center to the
    // surface centroid
    MFloat dotProduct = 0.0;
    for(MInt k = 0; k < nDim; k++) {
      const MFloat vecCenter = coordinates[i * nDim + k] - geomCenter[k];
      dotProduct += normalVecs[i * nDim + k] * vecCenter;
    }
    // If the dot product is positive the two vectors are pointing in the same 'direction', i.e.,
    // the angle between the vectors is less than 90deg; thus if not >0 change the sign of the
    // normal vector to point outside the geometry
    if(!(dotProduct > 0)) {
      for(MInt k = 0; k < nDim; k++) {
        normalVecs[i * nDim + k] = -normalVecs[i * nDim + k];
      }
    }
  }
 
  const MFloat totalGeomMeasure = std::accumulate(geomMeasures.begin(), geomMeasures.end(), 0.0);
  const MString measure = (nDim == 3) ? "area" : "length";
  m_log << "Total segment " << measure << ": " << totalGeomMeasure << std::endl;
 
  // TODO labels:PP for DEBUG
  std::stringstream dumpFileName;
  dumpFileName << solver().outputDir() << "surface_geometryInfo_" << fileNo << ".dump";
  // DEBUG output for plotting
  FILE* datei;
  datei = fopen(dumpFileName.str().c_str(), "w");
  /* datei = fopen("geometryInfo.dump", "a+"); */
  for(MInt i = 0; i < noElements; i++) {
    fprintf(datei, "%d", i);
 
    for(MInt j = 0; j < nDim; j++) {
      fprintf(datei, " %.8f", coordinates[i * nDim + j]);
    }
 
    for(MInt j = 0; j < nDim; j++) {
      fprintf(datei, " %.8f", normalVecs[i * nDim + j]);
    }
    fprintf(datei, "\n");
  }
  fclose(datei);
 
  const MInt sizeArray1 = noElements * nDim;
  const MInt sizeArray2 = noElements * nDim * nDim;
 
  // Write out geomInfo in output file
  file.defineArray(PIO_FLOAT, "vertices", sizeArray2);
  file.defineArray(PIO_FLOAT, "centroid", sizeArray1);
  file.defineArray(PIO_FLOAT, "normalVector", sizeArray1);
 
  file.defineArray(PIO_FLOAT, "geomMeasure", noElements);
  IF_CONSTEXPR(nDim == 3) { file.setAttribute("area", "description", "geomMeasure"); }
  else {
    file.setAttribute("length", "description", "geomMeasure");
  }
 
  file.setOffset(sizeArray2, 0);
  file.writeArray(&vertices[0], "vertices");
 
  file.setOffset(sizeArray1, 0);
  file.writeArray(&coordinates[0], "centroid");
 
  file.setOffset(sizeArray1, 0);
  file.writeArray(&normalVecs[0], "normalVector");
 
  file.setOffset(noElements, 0);
  file.writeArray(&geomMeasures[0], "geomMeasure");
}

◆ solver() [1/2]

template<MInt nDim, class SolverType >

SolverType & SamplingData< nDim, SolverType >::solver ( )

inline

Definition at line 129 of file samplingdata.h.

129{ return m_solver; }

◆ solver() [2/2]

template<MInt nDim, class SolverType >

const SolverType & SamplingData< nDim, SolverType >::solver ( ) const

inline

Definition at line 130 of file samplingdata.h.

130{ return m_solver; }

◆ solverId()

template<MInt nDim, class SolverType >

MInt SamplingData< nDim, SolverType >::solverId ( ) const

inline

Definition at line 118 of file samplingdata.h.

118{ return m_solver.solverId(); }

Member Data Documentation

◆ m_enabled

template<MInt nDim, class SolverType >

MBool SamplingData< nDim, SolverType >::m_enabled

Definition at line 134 of file samplingdata.h.

◆ m_geometry

template<MInt nDim, class SolverType >

GeometryXD<nDim>::type* SurfaceData< nDim, SolverType >::m_geometry = nullptr

private

Definition at line 214 of file samplingdata.h.

◆ m_timeSeries

template<MInt nDim, class SolverType >

std::vector<SamplingDataSeries> SamplingData< nDim, SolverType >::m_timeSeries

Definition at line 138 of file samplingdata.h.

The documentation for this class was generated from the following file:

/home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/POST/samplingdata.h

Public Types

Public Member Functions

Public Attributes

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ Base

Constructor & Destructor Documentation

◆ SurfaceData()

◆ ~SurfaceData()

Member Function Documentation

◆ getBaseName()

◆ isMpiRoot()

◆ loadInputFile()

◆ mpiComm()

◆ saveGeomInfo()

◆ solver() [1/2]

◆ solver() [2/2]

◆ solverId()

Member Data Documentation

◆ m_enabled

◆ m_geometry

◆ m_timeSeries