evFeatureDetector.h

Go to the documentation of this file.

/*
 *
 * EVITA: Efficient Visualization of Terascale Datasets
 * Copyright (C) 2000-2016  Team Evita
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 * 
 * This library 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
 * Library General Public License for more details.
 * 
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 675 Mass Ave, Cambridge,
 * MA 02139, USA.
 *
 */


#ifndef __evFeatureDetector_h
#define __evFeatureDetector_h


#include "evProcessObject.h"
#include "evDataset.h"


#define EVCOMPONENT_DENSITY 0
#define EVCOMPONENTNAME_DENSITY "Density"
#define EVCOMPONENT_VELOCITY 1
#define EVCOMPONENTNAME_VELOCITY "Velocity"
#define EVCOMPONENT_ENERGY 2
#define EVCOMPONENTNAME_ENERGY "Energy"
/*
#define EVCOMPONENT_GRID 0
#define EVCOMPONENTNAME_GRID "Grid"
#define EVCOMPONENT_DENSITY 1
#define EVCOMPONENTNAME_DENSITY "Density"
#define EVCOMPONENT_VELOCITY 2
#define EVCOMPONENTNAME_VELOCITY "Velocity"
#define EVCOMPONENT_ENERGY 3
#define EVCOMPONENTNAME_ENERGY "Energy"
*/


class evFeatureDetector : public evProcessObject
{
public:
  evFeatureDetector(void);
  virtual ~evFeatureDetector(void);
  
  virtual const evString GetClassName(void) const
  {
    return(evString("evFeatureDetector"));
  }
  
  virtual int DetectFeatures(const evDataset &dataset,
                             evScalarField &significance_map) const = 0;
  
protected:
  
  //  const evVectorField &GetGrid(const evDataset &dataset) const;
  void CalculateGrid(const evDataset &dataset, evVectorField &grid) const;

  const evVectorField &GetDensity(const evDataset &dataset) const;
  const evVectorField &GetVelocity(const evDataset &dataset) const;
  const evVectorField &GetEnergy(const evDataset &dataset) const;

  void CalculatePressure(const evDataset &dataset,
                         evScalarField &pressure) const;

  void CalculateXYZGradients(const evVectorField &grid_field,
                             evVectorField &psi_gradient,
                             evVectorField &eta_gradient) const;
  void CalculateGradient(const evScalarField &field,
                         const evVectorField &psi_gradient,
                         const evVectorField &eta_gradient,
                         evVectorField &gradient) const;
  void CalculateGradient(const evVectorField &field,
                         const unsigned int component,
                         const evVectorField &psi_gradient,
                         const evVectorField &eta_gradient,
                         evVectorField &gradient) const;
  double CalculateSoundSpeed(const double pressure,
                             const double density) const;
  int CalculateSoundSpeed(const evScalarField &pressure,
                          const evScalarField &density,
                          evScalarField &sound_speed) const;
  double CalculateMachNumber(const evVector &velocity,
                             const double pressure,
                             const double density) const;
  int CalculateMachNumber(const evVectorField &velocity,
                          const evScalarField &pressure,
                          const evScalarField &density,
                          evScalarField &mach_number) const;
  double CalculateNormalMachNumber(const evVector &velocity,
                                   const evVector &pressure_gradient,
                                   const double pressure,
                                   const double density) const;
  int CalculateNormalMachNumber(const evVectorField &velocity,
                                const evVectorField &pressure_gradient,
                                const evScalarField &pressure,
                                const evVectorField &density,
                                evScalarField &normal_mach_number) const;

private:
  
  void Initialize(void);

};


/*
inline const evVectorField &evFeatureDetector::GetGrid(const evDataset
                                                       &dataset) const
{
  const evROI &roi = *dataset.GetROIList()->GetFirst();
  return(*roi.GetComponent(EVCOMPONENT_GRID));
}
*/

inline const evVectorField &evFeatureDetector::GetDensity(const evDataset
                                                          &dataset) const
{
  unsigned int density_component = EVCOMPONENT_DENSITY;
  
  /*
  unsigned int density_component =
    (dataset.HasExplicitGrid()) ?
    EVCOMPONENT_DENSITY : EVCOMPONENT_DENSITY - 1;
  */
  
  return(*dataset.GetROIList()->GetFirst()->GetComponent(density_component));
}


inline const evVectorField &evFeatureDetector::GetVelocity(const evDataset
                                                           &dataset) const
{
  unsigned int velocity_component = EVCOMPONENT_VELOCITY;
  
  /*
  unsigned int velocity_component =
    (dataset.HasExplicitGrid()) ?
    EVCOMPONENT_VELOCITY : EVCOMPONENT_VELOCITY - 1;
  */
  
  return(*dataset.GetROIList()->GetFirst()->GetComponent(velocity_component));
}


inline const evVectorField &evFeatureDetector::GetEnergy(const evDataset
                                                         &dataset) const
{
  unsigned int energy_component = EVCOMPONENT_ENERGY;
  
  /*
  unsigned int energy_component =
    (dataset.HasExplicitGrid()) ?
    EVCOMPONENT_ENERGY : EVCOMPONENT_ENERGY - 1;
  */
  
  return(*dataset.GetROIList()->GetFirst()->GetComponent(energy_component));
}


inline double evFeatureDetector::CalculateSoundSpeed(const double pressure,
                                                     const double density)
     const
{
  const double gamma = 1.4;
  return(sqrt((gamma) * (pressure / density)));
}


inline double evFeatureDetector::CalculateMachNumber(const evVector &velocity,
                                                     const double pressure,
                                                     const double density)
     const
{
  return(velocity.Norm() / this->CalculateSoundSpeed(pressure, density));
}


inline double evFeatureDetector::CalculateNormalMachNumber(const evVector
                                                           &velocity,
                                                           const evVector
                                                           &pressure_gradient,
                                                           const double
                                                           pressure,
                                                           const double
                                                           density)
     const
{
  return(velocity * pressure_gradient /
         (QccMathMax(pressure_gradient.Norm(), 0.001) *
          this->CalculateSoundSpeed(pressure, density)));
}


#endif