amroc/amr/F77Interfaces/F77BrepOutput.h

Go to the documentation of this file.

// -*- C++ -*-

// Copyright (C) 2009 Ralf Deiterding

#ifndef AMROC_F77_BREP_OUTPUT_H
#define AMROC_F77_BREP_OUTPUT_H

#include "F77FileOutput.h"
#include "BrepOutput.h"

template <class VectorType, int dim>
class F77BrepOutput : public F77OutBase<VectorType,dim>,
  public BrepOutput<VectorType,dim> {
  typedef typename VectorType::InternalDataType DataType;
  typedef BrepOutput<VectorType,dim> base;
  typedef F77OutBase<VectorType,dim> out_base;
public:
  typedef typename base::vec_grid_fct_type vec_grid_fct_type;  
  typedef typename base::grid_fct_type grid_fct_type;
  typedef typename base::interpolation_type interpolation_type;
  typedef typename base::point_type point_type;
  typedef typename out_base::generic_func_type generic_func_type;
  typedef GridData<VectorType,dim> vec_grid_data_type;  
  typedef GridData<DataType,dim> grid_data_type;  

  F77BrepOutput(interpolation_type* interpol, generic_func_type out) : out_base(out), base(interpol) {}

  virtual ~F77BrepOutput() {}

  virtual void WriteOut(vec_grid_fct_type& u, 
                        const int num_vertices, const DataType* vertices,
                        const int num_connections, const int* connections) {

    VectorType* data = new VectorType[num_vertices];
    int Time = CurrentTime(base::GH(),0);
    double t = GetPhysicalTime(u,Time,0);
    base::Interpolation().PointsValues(u,t,num_vertices,(const point_type*)vertices,data);
    int NValues = num_vertices*base::NEquations();
    base::Interpolation().ArrayCombine(VizServer,NValues,(DataType *)data);

    if (MY_PROC==VizServer) {
      DataType* output_data = new DataType[base::Ncnt()*num_vertices];
      BBox bb(dim,1);
      bb.lower() = 0; bb.upper() = 0;
      bb.upper()(0) = num_vertices-1;
      vec_grid_data_type val(bb,data);
      for (int cnt=1;cnt<=base::Ncnt(); cnt++) {
        if (base::OutputName(cnt-1).c_str()[0] == '-') continue;
        grid_data_type output(bb,output_data+(cnt-1)*num_vertices);
        if (dim == 1) 
          ((typename out_base::out_1_func_type) (out_base::f_out))(FA(1,val),FA(1,output),BOUNDING_BOX(bb),
                                                                   base::NEquations(),cnt,t);
        else if (dim == 2) 
          ((typename out_base::out_2_func_type) (out_base::f_out))(FA(2,val),FA(2,output),BOUNDING_BOX(bb),
                                                                   base::NEquations(),cnt,t);
        else if (dim == 3) 
          ((typename out_base::out_3_func_type) (out_base::f_out))(FA(3,val),FA(3,output),BOUNDING_BOX(bb),
                                                                   base::NEquations(),cnt,t);
        for (register int i=0; i<num_vertices; i++)
          if (data[i](0)==base::Interpolation().ErrorValue())
            output_data[(cnt-1)*num_vertices+i]=base::Interpolation().ErrorValue();

        DataType* dummy;
        output.deallocate(dummy);
      }
      VectorType* dummy;
      val.deallocate(dummy);

      base::WriteMesh(num_vertices,vertices,num_connections,connections,Time,t,output_data);

      delete [] output_data;
    }
    delete [] data;
  } 
};

#endif      

---