amroc/converters/Evaluators/ScalarEvaluator.h

Go to the documentation of this file.

// -*- C++ -*-

// Copyright (C) 2002 Ralf Deiterding
// Brandenburgische Universitaet Cottbus
//
// Copyright (C) 2003-2007 California Institute of Technology
// Ralf Deiterding, ralf@cacr.caltech.edu

#ifndef AMROC_SCALAREVALUATOR_H
#define AMROC_SCALAREVALUATOR_H

#include <iostream>
#include <cstdio>
#include <cfloat>

#include "Evaluator.h"

template <class VectorType>
class ScalarEvaluator : public Evaluator<VectorType> {
  typedef Evaluator<VectorType> base;
  typedef typename VectorType::InternalDataType DataType;

public:
  typedef typename base::vector_block_type vector_block_type;
  typedef typename base::data_block_type data_block_type;

  ScalarEvaluator() : base() {
    std::sprintf(base::title,"Scalar function");
  }

  virtual void SetUp(VisualGridBase *gr) {
    EvaluatorBase::SetUp(gr);

    std::sprintf(&(base::tkeys[0*LEN_TKEYS]), "Distribution            ");
    std::sprintf(&(base::tkeys[1*LEN_TKEYS]), "Levels                  ");
    std::sprintf(&(base::tkeys[2*LEN_TKEYS]), "Function                ");
    std::sprintf(&(base::tkeys[3*LEN_TKEYS]), "Schl.-Plot Function     ");
    std::sprintf(&(base::tkeys[4*LEN_TKEYS]), "Gradient x-direction    ");
    std::sprintf(&(base::tkeys[5*LEN_TKEYS]), "Gradient y-direction    ");
    std::sprintf(&(base::tkeys[6*LEN_TKEYS]), "Gradient z-direction    ");
    base::fkeys[0] = base::Grid->FKeys();
    base::fkeys[1] = base::Grid->FKeys();
    base::fkeys[2] = base::Grid->FKeys();
    base::fkeys[3] = base::Grid->FKeys();
    base::fkeys[4] = base::Grid->FKeys();
    base::fkeys[5] = base::Grid->FKeys();
    base::fkeys[6] = base::Grid->FKeys();
    base::ikeys[0] = 105; base::ikeys[1] = 115; 
    base::ikeys[2] = 102; base::ikeys[3] = 70; 
    base::ikeys[4] = 120; base::ikeys[5] = 121; 
    base::ikeys[6] = 122; 
  }    

  virtual int NKeys() const { return 7; }

  virtual void SetScalCells(int key,float v[],int& offset, 
                            vector_block_type& DB, float* dx, bool* CompRead) {
    int idx=0;
    int keym1 = key-1;
    if (key==3 || key==4) {
      BeginFastIndex3(dat, DB.bbox(), DB.data(), VectorType);
      for_3 (i,j,k,DB.bbox(),DB.bbox().stepsize())
        v[idx+offset]= FastIndex3(dat,i,j,k)(0);
        base::mvals[2*keym1]   = Min(base::mvals[2*keym1],   v[idx+offset]);
        base::mvals[2*keym1+1] = Max(base::mvals[2*keym1+1], v[idx+offset]);
        idx++;        
      end_for
      EndFastIndex3(dat); 
    }
    offset+=idx;
    if (key>=4)
      std::cerr << &(base::tkeys[(key-1)*LEN_TKEYS])
                << " is NOT supported for Type=6. Use Type=1 instead!"
                << std::endl; 
  }
 
  virtual void SetScalNodes(int key,float v[],int& offset,
                            vector_block_type& DB, const BBox& bbox, 
                            float* dx, bool* CompRead) {
    int idx=0;
    int keym1 = key-1;
    BeginFastIndex3(dat, DB.bbox(), DB.data(), VectorType);
    const Coords& step = bbox.stepsize();
    switch(key) {
    case 3: 
      {
        for_3 (i,j,k,bbox,step)
          BBox AddOver(3,i-step(0),j-step(1),k-step(2),
                       i,j,k,step(0),step(1),step(2));
          AddOver *= DB.bbox();
          
          float c=0;
          v[idx+offset] = 0.0;
          for_3 (l, m, n, AddOver, step)
            if (FastIndex3(dat,l,m,n)(0) < FLT_MAX) {
              v[idx+offset] += FastIndex3(dat,l,m,n)(0);
              c += 1.0;
            }
          end_for
          if (c>0) v[idx+offset] /= c;
          else v[idx+offset] = FLT_MAX;

          base::mvals[2*keym1]   = Min(base::mvals[2*keym1],   v[idx+offset]);
          base::mvals[2*keym1+1] = Max(base::mvals[2*keym1+1], v[idx+offset]);
          idx++;              
        end_for 
        break;
      }

    case 4:
      {
        for_3 (i,j,k,bbox,step)
          BBox AddOver(3,i-step(0),j-step(1),k-step(2),
                       i,j,k,step(0),step(1),step(2));
          AddOver *= DB.bbox();

          data_block_type DBHelp(AddOver);
          BeginFastIndex3(help, DBHelp.bbox(), DBHelp.data(), DataType);
          for_3 (l, m, n, AddOver, step)
            FastIndex3(help,l,m,n) = FastIndex3(dat,l,m,n)(0);
          end_for
          EndFastIndex3(help); 
          v[idx+offset] = base::SetScalGradNodes(DBHelp,dx);
        
          base::mvals[2*keym1]   = Min(base::mvals[2*keym1],   v[idx+offset]);
          base::mvals[2*keym1+1] = Max(base::mvals[2*keym1+1], v[idx+offset]);
          idx++;              
        end_for 
        break;
      }

    case 5:
    case 6:
    case 7:
      {
        for_3 (i,j,k,bbox,step)
          BBox AddOver(3,i-step(0),j-step(1),k-step(2),
                       i,j,k,step(0),step(1),step(2));
          AddOver *= DB.bbox();

          data_block_type DBHelp(AddOver);
          BeginFastIndex3(help, DBHelp.bbox(), DBHelp.data(), DataType);
          for_3 (l, m, n, AddOver, step)
            FastIndex3(help,l,m,n) = FastIndex3(dat,l,m,n)(0);
          end_for
          EndFastIndex3(help); 
          v[idx+offset] = base::ScalDerivNodes(DBHelp,dx,key-5);
        
          base::mvals[2*keym1]   = Min(base::mvals[2*keym1],   v[idx+offset]);
          base::mvals[2*keym1+1] = Max(base::mvals[2*keym1+1], v[idx+offset]);
          idx++;              
        end_for 
        break;
      }

    default:
      break;
    }
    EndFastIndex3(dat); 
    offset+=idx;
  }
};


#endif

---