fsi/sfc-amroc/VibratingPanel/src/FluidProblem.h

Go to the documentation of this file.

// -*- C++ -*-

// Copyright (C) 2003-2007 California Institute of Technology
// Ralf Deiterding, ralf@amroc.net

#ifndef AMROC_FLUIDPROBLEM_H
#define AMROC_FLUIDPROBLEM_H

#include "euler3.h"
#include "ClpProblem.h"

#define MaxIntPoints (20)
#define OWN_ELCGFMAMRSOLVER

#include "ClpStdELCGFMProblem.h" 
#include "AMRGFMInterpolation.h"

class FluidSolverSpecific : 
  public AMRELCGFMSolver<VectorType,FixupType,FlagType,DIM> {
  typedef VectorType::InternalDataType DataType;
  typedef AMRELCGFMSolver<VectorType,FixupType,FlagType,DIM> base;
  typedef AMRGFMInterpolation<VectorType,FixupType,FlagType,DIM> interpolation_type;
public:
  typedef F77GFMFileOutput<VectorType,FixupType,FlagType,DIM> output_type;
  typedef base::point_type point_type;

  FluidSolverSpecific() : base(_IntegratorSpecific, _InitialConditionSpecific, 
                               _BoundaryConditionsSpecific) {
    SetLevelTransfer(new F77LevelTransfer<VectorType,DIM>(f_prolong, f_restrict));
    SetFileOutput(new output_type(*this,f_flgout)); 
    SetFixup(new FixupSpecific(_IntegratorSpecific));
    SetFlagging(new FlaggingSpecific(*this)); 
    AddGFM(new GhostFluidMethod<VectorType,DIM>(
              new F77ELCGFMBoundary<VectorType,DIM>(f_ibndrfl,f_itrans,*this),
              new CPTLevelSet<DataType,DIM>()));
    SetCoupleGFM(0);
    _Interpolation = new interpolation_type(*this);
    _IntName = "ptrack.txt";
  }  
 
  ~FluidSolverSpecific() {
    DeleteGFM(_GFM[0]);
    delete _Flagging;
    delete _Fixup;
    delete _Interpolation;
  }

  virtual void register_at(ControlDevice& Ctrl, const std::string& prefix) {
    base::register_at(Ctrl,prefix);
    IntCtrl = base::LocCtrl.getSubDevice("TrackPressure");
    RegisterAt(IntCtrl,"NPoints",_NIntPoints);
    char VariableName[32];
    for (int nc=0; nc<MaxIntPoints; nc++) {
      for (int d=0; d<base::Dim(); d++) {
        std::sprintf(VariableName,"Point(%d,%d)",nc+1,d+1);
        RegisterAt(IntCtrl,VariableName,_IntPoints[nc](d)); 
        _IntPoints[nc](d) = 0.0;
      }
    }
    RegisterAt(IntCtrl,"FileName",_IntName);
  } 
  virtual void register_at(ControlDevice& Ctrl) {
    base::register_at(Ctrl);
  }

  virtual void SetupData() {
    base::SetupData();
    _Interpolation->SetupData(base::PGH(), base::NGhosts());
  }

  virtual void SendBoundaryData() {
    START_WATCH
      for (register int l=0; l<=FineLevel(base::GH()); l++) 
        ((output_type*) _FileOutput)->Transform(base::U(), base::Work(), 
                                                CurrentTime(base::GH(),l), l, 
                                                base::Dim()+4, base::t[l]);
    END_WATCH(FLUID_CPL_PRESSURE_CALCULATE)
    base::SendBoundaryData();
  }

  virtual void Advance(double& t, double& dt) {
    base::Advance(t,dt);
    if (_NIntPoints<=0 || _NIntPoints>MaxIntPoints) return;

    int me = MY_PROC;
    // Calculate pressure
    for (register int l=0; l<=FineLevel(base::GH()); l++) {
      int Time = CurrentTime(base::GH(),l);
      int press_cnt = base::Dim()+4;
      ((output_type*) _FileOutput)->Transform(base::U(), base::Work(), Time, l, 
                                              press_cnt, base::t[l]);
    }

    DataType* p = new DataType[_NIntPoints];
    _Interpolation->PointsValues(base::Work(),base::t[0],_NIntPoints,_IntPoints,p);
    _Interpolation->ArrayCombine(VizServer,_NIntPoints,p);

    // Append to output file only on processor VizServer
    if (me == VizServer) {
      std::ofstream outfile;
      std::ostream* out;
      outfile.open(_IntName.c_str(), std::ios::out | std::ios::app);
      out = new std::ostream(outfile.rdbuf());
      *out << base::t[0];
      for (int ns=0; ns<_NIntPoints; ns++)
        *out << " " << p[ns]; 
      *out << std::endl;
      outfile.close();
      delete out;      
    }

    delete [] p;
  } 

protected:
  IntegratorSpecific _IntegratorSpecific;
  InitialConditionSpecific _InitialConditionSpecific;
  BoundaryConditionsSpecific _BoundaryConditionsSpecific;
  interpolation_type* _Interpolation; 
  ControlDevice IntCtrl;
  int _NIntPoints;
  point_type _IntPoints[MaxIntPoints];
  std::string _IntName;