src/aclvis/poomastub.cpp

Go to the documentation of this file.

// -*- C++ -*-
/***************************************************************************
 *
 * The IPPL Framework
 * 
 * This program was prepared by PSI. 
 * All rights in the program are reserved by PSI.
 * Neither PSI nor the author(s)
 * makes any warranty, express or implied, or assumes any liability or
 * responsibility for the use of this software
 *
 * Visit http://www.acl.lanl.gov/POOMS for more details
 *
 ***************************************************************************/

// -*- C++ -*-
/***************************************************************************
 *
 * The IPPL Framework
 * 
 *
 * Visit http://people.web.psi.ch/adelmann/ for more details
 *
 ***************************************************************************/

// 
// create iso-surface of the Lorenz attractor
//

#ifdef IPPL_USE_STANDARD_HEADERS
#include <iostream>
using namespace std;
#else
#include <iostream.h>
#endif

#include <vtk.h>
#include "Profile/Profiler.h"

float   Pr = 10.0;      // The Lorenz parameters
float   b = 2.667;
float   r = 28.0;
float   x, y, z;        // starting (and current) x, y, z 
float   h = 0.01;       // integration step size 
int     resolution=200; // slice resolution 
//int     iter = 10000000;        // number of iterations 
int     iter = 100;        // number of iterations 
float   xmin = -30.0;   // x, y, z range for voxels 
float   xmax = 30.0;
float   ymin = -30.0;
float   ymax = 30.0;
float   zmin = -10.0;
float   zmax = 60.0;

int randomMode = 1;
float xIncr, yIncr, zIncr;
short   *slice;

void Lorenz(vtkStructuredPoints *vizdata, float Pr) {
  TAU_PROFILE("Lorenz()", "void (vtkStructuredPoints *, float)", TAU_VIZ);

  vtkShortScalars *scalars;

  int   i, j;        
  float xx, yy, zz;
  short xxx, yyy, zzz;
  int   sliceSize;

  short *s;
  void options(int, char**);
  int numPts, index;
  vtkMath math;

  // take a stab at an integration step size
  xIncr = resolution / (xmax - xmin);
  yIncr = resolution / (ymax - ymin);
  zIncr = resolution / (zmax - zmin);

  // printf ("The Lorenz Attractor\n");
  // printf ("     Pr = %f\n", Pr);
  // printf ("     b = %f\n", b);
  // printf ("     r = %f\n", r);
  // printf ("     integration step size = %f\n", h);
  // printf ("     slice resolution = %d\n", resolution);
  // printf ("     # of iterations = %d\n", iter);
  // printf ("     specified range:\n");
  // printf ("             x: %f, %f\n", xmin, xmax);
  // printf ("             y: %f, %f\n", ymin, ymax);
  // printf ("             z: %f, %f\n", zmin, zmax);

  x = math.Random(xmin,xmax);
  y = math.Random(ymin,ymax);
  z = math.Random(zmin,zmax);
  // printf ("     starting at %f, %f, %f\n", x, y, z);

  // allocate memory for the slices
  sliceSize = resolution * resolution;
  numPts = sliceSize * resolution;
  scalars = new vtkShortScalars(numPts);
  //scalars = (vtkShortScalars *)vizdata->GetPointData()->GetScalars();
  s = scalars->WritePtr(0,numPts);
  for (i=0; i < numPts; i++) s[i] = 0;

  // printf ("     integrating...\n");
  for (j = 0; j < iter; j++) 
    {
    // integrate to next time step
    xx = x + h * Pr * (y - x);
    yy = y + h * (x * (r - z) - y);
    zz = z + h * (x * y - (b * z));

    x = xx; y = yy; z = zz;

    // calculate voxel index
    if (x < xmax && x > xmin && y < ymax && y > ymin && z < zmax && z > zmin) 
      {
      xxx = (short) ((float)(xx - xmin) * xIncr);
      yyy = (short) ((float)(yy - ymin) * yIncr);
      zzz = (short) ((float)(zz - zmin) * zIncr);
      index = xxx + yyy*resolution + zzz*sliceSize;
      s[index] += 1;
      }
    }
  scalars->WrotePtr();
  vizdata->GetPointData()->SetScalars(scalars);
  vizdata->SetDimensions(resolution,resolution,resolution);
  vizdata->SetOrigin(xmin,ymin,zmin);
  vizdata->SetAspectRatio((xmax-xmin)/resolution, (ymax-ymin)/resolution, (zmax-zmin)/resolution);
  scalars->Delete();
}


#include "aclvis/ipplstub.h"

ConnectStub::ConnectStub(int type_param) {
  TAU_PROFILE("ConnectStub::ConnectStub()", "void (int)", TAU_VIZ);
  type = type_param;
  if (type == ACLVIS) {
    connection = new VizTool();
  }
}

int ConnectStub::GetType(){
  TAU_PROFILE("ConnectStub::GetType()", "int ()", TAU_VIZ);
  return type;
}

void ConnectStub::SetType(int type_param){
  TAU_PROFILE("ConnectStub::SetType()", "void (int)", TAU_VIZ);
  type = type_param;
}
 
void *ConnectStub::GetConnection(){
  TAU_PROFILE("ConnectStub::GetConnection()", "void ()", TAU_VIZ);
  return connection;
}

void ConnectStub::SetConnection(void *connection_param) {
  TAU_PROFILE("ConnectStub::SetConnection()", "void (void *)", TAU_VIZ);
  connection = connection_param;
}

void FieldStub::connect(ConnectStub *connect_stub_param,
                        char *name, ConnectDataType ctype){
  TAU_PROFILE("FieldStub::connect()", "void (ConnectStub *, char *, ConnectDataType)", 
    TAU_VIZ);
  VizTool *viztool;

  connectDataType = ctype;
  if (ctype == FieldDataType) {
    readtool = new ReadFieldTool;
  } else {
    readtool = new ReadParticleTool;
  }

  connect_stub = connect_stub_param;
  if (connect_stub->GetType() == ACLVIS) {
    viztool = (VizTool *)connect_stub->GetConnection();
    viztool->connect(this, name, readtool, ctype);
  }
}

void FieldStub::update(float Pr){
  TAU_PROFILE("FieldStub::update()", "void (float)", TAU_VIZ);
  VizTool *viztool;

  if (connectDataType == FieldDataType) {
    ReadFieldTool *readFieldTool;
    readFieldTool = (ReadFieldTool *)readtool;
    Lorenz(readFieldTool->GetOutput(),Pr);
  }
    
  //cerr << "ippl-stub: \n";
  if (connect_stub->GetType() == ACLVIS) {
    viztool = (VizTool *)connect_stub->GetConnection();
    viztool->update(this);
  }
}

void FieldStub::interact(int flag){
  TAU_PROFILE("FieldStub::interact()", "void (int)", TAU_VIZ);
  VizTool *viztool;

  if (connect_stub->GetType() == ACLVIS) {

    viztool = (VizTool *)connect_stub->GetConnection();
    viztool->Interact(flag);
  }
}

void FieldStub::disconnect(){
  TAU_PROFILE("FieldStub::disconnect()", "void ()", TAU_VIZ);
  VizTool *viztool;

  if (connect_stub->GetType() == ACLVIS) {
    viztool = (VizTool *)connect_stub->GetConnection();
    viztool->disconnect(this);
  }
}


/***************************************************************************
 * $RCSfile: ipplstub.cpp,v $   $Author: adelmann $
 * $Revision: 1.1.1.1 $   $Date: 2003/01/23 07:40:34 $
 * IPPL_VERSION_ID: $Id: ipplstub.cpp,v 1.1.1.1 2003/01/23 07:40:34 adelmann Exp $ 
 ***************************************************************************/

---