AcaPostProcessingRMS< nDim > Class Template Reference

ACA post processing class for calculation of root mean square pressure. More...

#include <acapostprocessing.hpp>

Inheritance diagram for AcaPostProcessingRMS< nDim >:

Collaboration diagram for AcaPostProcessingRMS< nDim >:

Public Member Functions
void	init_ () override
void	calc (const MInt observerId, const MFloat *const data, const MFloat *const dataComplex=nullptr) override
void	finish () override
	AcaPostProcessing (const MPI_Comm comm)
Public Member Functions inherited from AcaPostProcessing
	AcaPostProcessing (const MPI_Comm comm)
virtual	~AcaPostProcessing ()=default
virtual void	init_ ()=0
void	init (const MInt noObservers, const MInt noGlobalObservers, const MInt offsetObserver, const MInt noSamples, const MFloat *const coords, const MFloat *const frequencies, const MString outPath)
virtual void	calc (const MInt observerId, const MFloat *const data, const MFloat *const dataComplex=nullptr)=0
virtual void	finish ()=0

Private Attributes
MString	m_fileNameIoParallel
MString	m_fileNameIoDat
std::vector< MFloat >	m_prms

Additional Inherited Members
Protected Attributes inherited from AcaPostProcessing
MPI_Comm	m_mpiComm
MInt	m_rank
MInt	m_noObservers = -1
MInt	m_noGlobalObservers = -1
MInt	m_offsetObserver = 0
MInt	m_noSamples = -1
MString	m_outPath
const MFloat *	m_coords = nullptr
const MFloat *	m_frequencies = nullptr

Detailed Description

template<MInt nDim>
class AcaPostProcessingRMS< nDim >

Definition at line 127 of file acapostprocessing.hpp.

Member Function Documentation

AcaPostProcessing()

template<MInt nDim>

AcaPostProcessing::AcaPostProcessing ( const MPI_Comm  comm )

inline

Definition at line 25 of file acapostprocessing.h.

: m_mpiComm(comm) { MPI_Comm_rank(m_mpiComm, &m_rank); }

calc()

template<MInt nDim>

void AcaPostProcessingRMS< nDim >::calc ( const MInt  observerId, const MFloat *const  data, const MFloat *const  dataComplex = nullptr  )

overridevirtual

Implements AcaPostProcessing.

Definition at line 148 of file acapostprocessing.hpp.

                                                             {
  // Calculation of root mean square pressure values
  m_prms[m_offsetObserver + observerId] = 0;
  for(MInt t = 0; t < m_noSamples; t++) {
    m_prms[m_offsetObserver + observerId] += POW2(data[t]);
  }
  m_prms[m_offsetObserver + observerId] = sqrt(m_prms[m_offsetObserver + observerId] / m_noSamples);
}

finish()

template<MInt nDim>

void AcaPostProcessingRMS< nDim >::finish

overridevirtual

Implements AcaPostProcessing.

Definition at line 159 of file acapostprocessing.hpp.

                                        {
  constexpr MInt rootId = 0;
  using namespace maia::parallel_io;
  ParallelIo file(m_fileNameIoParallel, PIO_REPLACE, m_mpiComm);
  ParallelIo::size_type dimSizesCoordinates[] = {m_noGlobalObservers, nDim};
  file.defineArray(PIO_FLOAT, "coordinates", 2, &dimSizesCoordinates[0]);
  file.defineArray(PIO_FLOAT, "rms_pressure", m_noGlobalObservers);
 
  const MBool isRoot = (m_rank == rootId);
  file.setOffset((isRoot) ? m_noGlobalObservers : 0, 0, 2);
  file.writeArray(m_coords, "coordinates");
  if(isRoot) {
    MPI_Reduce(MPI_IN_PLACE, m_prms.data(), m_noGlobalObservers, maia::type_traits<MFloat>::mpiType(), MPI_SUM, rootId,
               m_mpiComm, AT_, "MPI_IN_PLACE", "m_prms");
    // TODO labels:ACA,totest Check distl, theta, and alpha
    std::ofstream outfile;
    outfile.open(m_fileNameIoDat);
    if constexpr(nDim == 2) {
      outfile << "# obs:1 x:2 y:3 theta:4 p_rms:5" << std::endl;
      for(MInt obs = 0; obs < m_noGlobalObservers; obs++) {
        const MFloat* const obsCoord = &m_coords[nDim * obs];
        const MFloat theta = atan2(obsCoord[1], obsCoord[0]);
        outfile << obs << " " << obsCoord[0] << " " << obsCoord[1] << " " << theta << " " << m_prms[obs] << std::endl;
      }
    } else if constexpr(nDim == 3) {
      outfile << "# obs:1 x:2 y:3 z:4 theta:5 alpha:6 p_rms:7" << std::endl;
      for(MInt obs = 0; obs < m_noGlobalObservers; obs++) {
        const MFloat* const obsCoord = &m_coords[nDim * obs];
        const MFloat dist = sqrt(POW2(obsCoord[0]) + POW2(obsCoord[1]) + POW2(obsCoord[2]));
        const MFloat theta = atan2(obsCoord[2], obsCoord[0]);
        const MFloat alpha = asin(obsCoord[1] / dist);
        outfile << obs << " " << obsCoord[0] << " " << obsCoord[1] << " " << obsCoord[2] << " " << theta << " " << alpha
                << " " << m_prms[obs] << std::endl;
      }
    }
    outfile.close();
    file.setOffset(m_noGlobalObservers, 0);
  } else {
    MPI_Reduce(m_prms.data(), nullptr, m_noGlobalObservers, maia::type_traits<MFloat>::mpiType(), MPI_SUM, rootId,
               m_mpiComm, AT_, "MPI_IN_PLACE", "m_prms");
    file.setOffset(0, 0);
  }
  file.writeArray(m_prms.data(), "rms_pressure");
}

init_()

template<MInt nDim>

void AcaPostProcessingRMS< nDim >::init_

overridevirtual

Implements AcaPostProcessing.

Definition at line 141 of file acapostprocessing.hpp.

                                       {
  m_fileNameIoParallel = m_outPath + "RMSpressure" + ParallelIo::fileExt();
  m_fileNameIoDat = m_outPath + "RMS.dat";
  m_prms.resize(m_noGlobalObservers, 0.0);
}

Member Data Documentation

m_fileNameIoDat

template<MInt nDim>

MString AcaPostProcessingRMS< nDim >::m_fileNameIoDat

private

Definition at line 130 of file acapostprocessing.hpp.

m_fileNameIoParallel

template<MInt nDim>

MString AcaPostProcessingRMS< nDim >::m_fileNameIoParallel

private

Definition at line 129 of file acapostprocessing.hpp.

m_prms

template<MInt nDim>

std::vector<MFloat> AcaPostProcessingRMS< nDim >::m_prms

private

Definition at line 131 of file acapostprocessing.hpp.

---

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

• /home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/ACA/acapostprocessing.hpp