Garfield::ViewField Class Reference

#include <ViewField.hh>

Public Member Functions
	ViewField ()
	~ViewField ()
void	SetSensor (Sensor *s)
void	SetComponent (ComponentBase *c)
void	SetCanvas (TCanvas *c)
void	SetVoltageRange (const double minval, const double maxval)
void	SetElectricFieldRange (const double minval, const double maxval)
void	SetWeightingFieldRange (const double minval, const double maxval)
void	SetArea (double xmin, double ymin, double xmax, double ymax)
void	SetNumberOfContours (const int n)
void	SetDefaultProjection ()
void	SetPlane (double fx, double fy, double fz, double x0, double y0, double z0)
void	SetNumberOfSamples1d (const int n)
void	SetNumberOfSamples2d (const int nx, const int ny)
void	Rotate (double angle)
void	PlotContour (const std::string option="v")
void	PlotSurface (const std::string option="v")
void	PlotProfile (const double x0, const double y0, const double z0, const double x1, const double y1, const double z1, const std::string option="v")
void	PlotContourWeightingField (const std::string label, const std::string option)
void	PlotSurfaceWeightingField (const std::string label, const std::string option)
double	EvaluatePotential (double *pos, double *par)
double	EvaluatePotentialProfile (double *pos, double *par)
double	EvaluateWeightingField (double *pos, double *par)
void	EnableAcknowledgeStatus (const double v0=0.)
void	DisableAcknowledgeStatus ()
void	EnableDebugging ()
void	DisableDebugging ()

Detailed Description

Definition at line 13 of file ViewField.hh.

Constructor & Destructor Documentation

ViewField()

Garfield::ViewField::ViewField

(

)

Definition at line 17 of file ViewField.cc.

    : className("ViewField"),
      debug(false),
      useStatus(false),
      vBkg(0.),
      sensor(0),
      component(0),
      pxmin(-1.),
      pymin(-1.),
      pxmax(1.),
      pymax(1.),
      fmin(0.),
      fmax(100.),
      emin(0.),
      emax(10000.),
      wmin(0.),
      wmax(100.),
      nContours(nMaxContours),
      nSamples1d(1000),
      nSamples2dX(200),
      nSamples2dY(200),
      electrode(""),
      canvas(0),
      hasExternalCanvas(false),
      fPot(0),
      fWfield(0),
      fPotProfile(0) {
 
  SetDefaultProjection();
  plottingEngine.SetDefaultStyle();
}

~ViewField()

Garfield::ViewField::~ViewField

(

)

Definition at line 49 of file ViewField.cc.

                      {
 
  if (!hasExternalCanvas && canvas != 0) delete canvas;
  if (fPot != 0) delete fPot;
  if (fWfield != 0) delete fWfield;
  if (fPotProfile != 0) delete fPotProfile;
}

Member Function Documentation

DisableAcknowledgeStatus()

void Garfield::ViewField::DisableAcknowledgeStatus ( )

inline

Definition at line 60 of file ViewField.hh.

{ useStatus = false; }

DisableDebugging()

void Garfield::ViewField::DisableDebugging ( )

inline

Definition at line 63 of file ViewField.hh.

{ debug = false; }

EnableAcknowledgeStatus()

void Garfield::ViewField::EnableAcknowledgeStatus ( const double  v0 = 0. )

inline

Definition at line 56 of file ViewField.hh.

                                                     {
    useStatus = true;
    vBkg = v0;
  }

EnableDebugging()

void Garfield::ViewField::EnableDebugging ( )

inline

Definition at line 62 of file ViewField.hh.

{ debug = true; }

EvaluatePotential()

double Garfield::ViewField::EvaluatePotential	(	double *	pos,
		double *	par
	)

Definition at line 669 of file ViewField.cc.

                                                            {
 
  if (sensor == 0 && component == 0) return 0.;
 
  // Compute the field.
  double ex = 0., ey = 0., ez = 0., volt = 0.;
  int status = 0;
  Medium* medium;
  const double xpos =
      project[0][0] * pos[0] + project[1][0] * pos[1] + project[2][0];
  const double ypos =
      project[0][1] * pos[0] + project[1][1] * pos[1] + project[2][1];
  const double zpos =
      project[0][2] * pos[0] + project[1][2] * pos[1] + project[2][2];
 
  if (sensor == 0) {
    component->ElectricField(xpos, ypos, zpos, ex, ey, ez, volt, medium,
                             status);
  } else {
    sensor->ElectricField(xpos, ypos, zpos, ex, ey, ez, volt, medium, status);
  }
  if (debug) {
    std::cout << className << "::EvaluatePotential:\n";
    std::cout << "    At (u, v) = (" << pos[0] << ", " << pos[1] << "), "
              << " (x,y,z) = (" << xpos << "," << ypos << "," << zpos << ")\n";
    std::cout << "    E = " << ex << ", " << ey << ", " << ez
              << "), V = " << volt << ", status = " << status << "\n";
  }
 
  if (useStatus && status != 0) return vBkg;
 
  // Select the quantity to be plotted.
  if (par[0] > 30.) {
    return ez;
  } else if (par[0] > 20.) {
    return ey;
  } else if (par[0] > 10.) {
    return ex;
  } else if (par[0] > 0.) {
    return sqrt(ex * ex + ey * ey + ez * ez);
  }
  // Return the potential.
  return volt;
}

EvaluatePotentialProfile()

double Garfield::ViewField::EvaluatePotentialProfile	(	double *	pos,
		double *	par
	)

Definition at line 714 of file ViewField.cc.

                                                                   {
 
  if (sensor == 0 && component == 0) return 0.;
 
  // Get the start and end position.
  const double x0 = par[0];
  const double y0 = par[1];
  const double z0 = par[2];
  const double x1 = par[3];
  const double y1 = par[4];
  const double z1 = par[5];
  // Compute the direction.
  const double dx = x1 - x0;
  const double dy = y1 - y0;
  const double dz = z1 - z0;
  // Get the position.
  const double t = pos[0];
 
  // Compute the field.
  double ex = 0., ey = 0., ez = 0., volt = 0.;
  int status = 0;
  Medium* medium;
 
  if (sensor == 0) {
    component->ElectricField(x0 + t * dx, y0 + t * dy, z0 + t * dz, ex, ey, ez,
                             volt, medium, status);
  } else {
    sensor->ElectricField(x0 + t * dx, y0 + t * dy, z0 + t * dz, ex, ey, ez,
                          volt, medium, status);
  }
 
  if (useStatus && status != 0) volt = vBkg;
 
  // Select the quantity to be plotted.
  if (par[6] > 30.) {
    return ez;
  } else if (par[6] > 20.) {
    return ey;
  } else if (par[6] > 10.) {
    return ex;
  } else if (par[6] > 0.) {
    return sqrt(ex * ex + ey * ey + ez * ez);
  }
  // Return the potential.
  return volt;
}

EvaluateWeightingField()

double Garfield::ViewField::EvaluateWeightingField	(	double *	pos,
		double *	par
	)

Definition at line 761 of file ViewField.cc.

                                                                 {
 
  if (sensor == 0 && component == 0) return 0.;
 
  // Compute the field.
  double ex = 0., ey = 0., ez = 0., v = 0.;
  const double xpos =
      project[0][0] * pos[0] + project[1][0] * pos[1] + project[2][0];
  const double ypos =
      project[0][1] * pos[0] + project[1][1] * pos[1] + project[2][1];
  const double zpos =
      project[0][2] * pos[0] + project[1][2] * pos[1] + project[2][2];
 
  if (sensor == 0) {
    if (par[0] > 0.) {
      component->WeightingField(xpos, ypos, zpos, ex, ey, ez, electrode);
    } else {
      v = component->WeightingPotential(xpos, ypos, zpos, electrode);
    }
  } else {
    if (par[0] > 0.) {
      sensor->WeightingField(xpos, ypos, zpos, ex, ey, ez, electrode);
    } else {
      v = sensor->WeightingPotential(xpos, ypos, zpos, electrode);
    }
  }
  if (debug) {
    std::cout << className << "::EvaluateWeightingField:\n";
    std::cout << "    At (u, v) = (" << pos[0] << ", " << pos[1] << "), "
              << " (x, y, z) = (" << xpos << "," << ypos << "," << zpos
              << ")\n";
    if (par[0] > 0.) {
      std::cout << "    E = (" << ex << ", " << ey << ", " << ez << ")\n";
    } else {
      std::cout << "    V = " << v << "\n";
    }
  }
 
  // Select the quantity to be plotted.
  if (par[0] < 0.) {
    return v;
  } else if (par[0] > 30.) {
    return ez;
  } else if (par[0] > 20.) {
    return ey;
  } else if (par[0] > 10.) {
    return ex;
  } else {
    return sqrt(ex * ex + ey * ey + ez * ez);
  }
}

PlotContour()

void Garfield::ViewField::PlotContour

(

const std::string

option = "v"

)

Definition at line 198 of file ViewField.cc.

                                                  {
 
  // Setup the canvas
  if (canvas == 0) {
    canvas = new TCanvas();
    canvas->SetTitle("Field View");
    if (hasExternalCanvas) hasExternalCanvas = false;
  }
  canvas->cd();
  canvas->Range(pxmin, pymin, pxmax, pymax);
 
  if (fPot == 0) CreateFunction();
 
  int plotType = 0;
  if (option == "v" || option == "p" || option == "phi" || option == "volt" ||
      option == "voltage" || option == "pot" || option == "potential") {
    fPot->SetParameter(0, -1.);
    fPot->SetRange(pxmin, pymin, pxmax, pymax);
    fPot->SetMinimum(fmin);
    fPot->SetMaximum(fmax);
  } else if (option == "e" || option == "field") {
    fPot->SetParameter(0, 1.);
    plotType = 1;
    fPot->SetMinimum(emin);
    fPot->SetMaximum(emax);
  } else if (option == "ex") {
    fPot->SetParameter(0, 11.);
    plotType = 2;
    fPot->SetMinimum(emin);
    fPot->SetMaximum(emax);
  } else if (option == "ey") {
    fPot->SetParameter(0, 21.);
    plotType = 3;
    fPot->SetMinimum(emin);
    fPot->SetMaximum(emax);
  } else if (option == "ez") {
    fPot->SetParameter(0, 31.);
    plotType = 4;
    fPot->SetMinimum(emin);
    fPot->SetMaximum(emax);
  } else {
    std::cerr << className << "::PlotContour:\n";
    std::cerr << "    Unknown option (" << option << ")\n";
    std::cerr << "    Plotting the potential.\n";
    fPot->SetParameter(0, -1.);
    fPot->SetMinimum(fmin);
    fPot->SetMaximum(fmax);
  }
 
  double level[nMaxContours];
  for (int i = 0; i < nContours; ++i) {
    if (nContours > 1) {
      if (plotType == 0) {
        level[i] = fmin + i * (fmax - fmin) / (nContours - 1.);
      } else {
        level[i] = emin + i * (emax - emin) / (nContours - 1.);
      }
    } else {
      if (plotType == 0) {
        level[i] = (fmax + fmin) / 2.;
      } else {
        level[i] = (emax + emin) / 2.;
      }
    }
  }
  fPot->SetContour(nContours, level);
 
  if (debug) {
    std::cout << className << "::PlotContour:\n";
    std::cout << "    Number of contours: " << nContours << "\n";
    for (int i = 0; i < nContours; ++i) {
      std::cout << "        Level " << i << " = " << level[i] << "\n";
    }
  }
  fPot->SetNpx(nSamples2dX);
  fPot->SetNpy(nSamples2dY);
  fPot->GetXaxis()->SetTitle(xLabel);
  fPot->GetYaxis()->SetTitle(yLabel);
  if (plotType == 0) {
    fPot->SetTitle("Contours of the potential");
  } else if (plotType == 1) {
    fPot->SetTitle("Contours of the electric field");
  } else if (plotType == 2) {
    fPot->SetTitle("Contours of the electric field (x-component)");
  } else if (plotType == 3) {
    fPot->SetTitle("Contours of the electric field (y-component)");
  } else if (plotType == 4) {
    fPot->SetTitle("Contours of the electric field (z-component)");
  }
  fPot->Draw("CONT4Z");
  canvas->Update();
}

PlotContourWeightingField()

void Garfield::ViewField::PlotContourWeightingField	(	const std::string	label,
		const std::string	option
	)

Definition at line 512 of file ViewField.cc.

                                                                  {
 
  // Setup the canvas
  if (canvas == 0) {
    canvas = new TCanvas();
    canvas->SetTitle("Field View");
    if (hasExternalCanvas) hasExternalCanvas = false;
  }
  canvas->cd();
  canvas->Range(pxmin, pymin, pxmax, pymax);
 
  electrode = label;
 
  if (fWfield == 0) CreateFunctionWeightingField();
 
  int plotType = 0;
  if (option == "v" || option == "p" || option == "phi" || option == "volt" ||
      option == "voltage" || option == "pot" || option == "potential") {
    fWfield->SetParameter(0, -1.);
  } else if (option == "e" || option == "field") {
    fWfield->SetParameter(0, 1.);
    plotType = 1;
  } else if (option == "ex") {
    fWfield->SetParameter(0, 11.);
    plotType = 2;
  } else if (option == "ey") {
    fWfield->SetParameter(0, 21.);
    plotType = 3;
  } else if (option == "ez") {
    fWfield->SetParameter(0, 31.);
    plotType = 4;
  } else {
    std::cerr << className << "::PlotContourWeightingField:\n";
    std::cerr << "    Unknown option (" << option << ")\n";
    std::cerr << "    Plotting the absolute value of the field.\n";
    fWfield->SetParameter(0, 1.);
  }
  fWfield->SetMinimum(wmin);
  fWfield->SetMaximum(wmax);
 
  double level[nMaxContours];
  for (int i = 0; i < nContours; ++i) {
    if (nContours > 1) {
      level[i] = i / (nContours - 1.);
      if (plotType > 0) {
        level[i] = wmin + (wmax - wmin) * level[i];
      }
    } else {
      level[i] = 1. / 2.;
      if (plotType > 0) {
        level[i] *= (wmax + wmin);
      }
    }
  }
  fWfield->SetContour(nContours, level);
 
  if (debug) {
    std::cout << className << "::PlotContour:\n";
    std::cout << "    Number of contours: " << nContours << "\n";
    for (int i = 0; i < nContours; ++i) {
      std::cout << "        Level " << i << " = " << level[i] << "\n";
    }
  }
  fWfield->SetNpx(nSamples2dX);
  fWfield->SetNpy(nSamples2dY);
  fWfield->GetXaxis()->SetTitle(xLabel);
  fWfield->GetYaxis()->SetTitle(yLabel);
  if (plotType == 0) {
    fWfield->SetTitle("Contours of the weighting potential");
  } else if (plotType == 1) {
    fWfield->SetTitle("Contours of the weighting field");
  } else if (plotType == 2) {
    fWfield->SetTitle("Contours of the weighting field (x-component)");
  } else if (plotType == 3) {
    fWfield->SetTitle("Contours of the weighting field (y-component)");
  } else if (plotType == 4) {
    fWfield->SetTitle("Contours of the weighting field (z-component)");
  }
  fWfield->Draw("CONT4Z");
  canvas->Update();
}

PlotProfile()

void Garfield::ViewField::PlotProfile	(	const double	x0,
		const double	y0,
		const double	z0,
		const double	x1,
		const double	y1,
		const double	z1,
		const std::string	option = "v"
	)

Definition at line 357 of file ViewField.cc.

                                                    {
 
  // Check the distance between the two points.
  const double d = sqrt(pow(x1 - x0, 2) + pow(y1 - y0, 2) + pow(z1 - z0, 2));
  if (d <= 0.) {
    std::cerr << className << "::PlotProfile:\n";
    std::cerr << "    Start and end point coincide.\n";
    return;
  }
 
  // Setup the canvas.
  if (canvas == 0) {
    canvas = new TCanvas();
    canvas->SetTitle("Field View");
    if (hasExternalCanvas) hasExternalCanvas = false;
  }
  canvas->cd();
 
  if (fPotProfile == 0) CreateProfileFunction();
 
  fPotProfile->SetParameter(0, x0);
  fPotProfile->SetParameter(1, y0);
  fPotProfile->SetParameter(2, z0);
  fPotProfile->SetParameter(3, x1);
  fPotProfile->SetParameter(4, y1);
  fPotProfile->SetParameter(5, z1);
  int plotType = 0;
  if (option == "v" || option == "p" || option == "phi" || option == "volt" ||
      option == "voltage" || option == "pot" || option == "potential") {
    fPotProfile->SetParameter(6, -1.);
    fPotProfile->SetMinimum(fmin);
    fPotProfile->SetMaximum(fmax);
  } else if (option == "e" || option == "field") {
    fPotProfile->SetParameter(6, 1.);
    plotType = 1;
    fPotProfile->SetMinimum(emin);
    fPotProfile->SetMaximum(emax);
  } else if (option == "ex") {
    fPotProfile->SetParameter(6, 11.);
    plotType = 2;
    fPotProfile->SetMinimum(emin);
    fPotProfile->SetMaximum(emax);
  } else if (option == "ey") {
    fPotProfile->SetParameter(6, 21.);
    plotType = 3;
    fPotProfile->SetMinimum(emin);
    fPotProfile->SetMaximum(emax);
  } else if (option == "ez") {
    fPotProfile->SetParameter(6, 31.);
    plotType = 4;
    fPotProfile->SetMinimum(emin);
    fPotProfile->SetMaximum(emax);
  } else {
    std::cerr << className << "::PlotProfile:\n";
    std::cerr << "    Unknown option (" << option << ")\n";
    std::cerr << "    Plotting the potential.\n";
    fPotProfile->SetParameter(6, -1.);
    fPotProfile->SetMinimum(fmin);
    fPotProfile->SetMaximum(fmax);
  }
  if (debug) {
    std::cout << className << "::PlotProfile:\n";
    if (plotType == 0) {
      std::cout << "    Plotting potential along\n";
    } else {
      std::cout << "    Plotting field along\n";
    }
    std::cout << "    (" << fPotProfile->GetParameter(0) << ", "
              << fPotProfile->GetParameter(1) << ", "
              << fPotProfile->GetParameter(2) << ") - ("
              << fPotProfile->GetParameter(3) << ", "
              << fPotProfile->GetParameter(4) << ", "
              << fPotProfile->GetParameter(5) << ")\n";
  }
  fPotProfile->GetXaxis()->SetTitle("normalised distance");
  if (plotType == 0) {
    fPotProfile->SetTitle("Profile plot of the potential");
    fPotProfile->GetYaxis()->SetTitle("potential [V]");
  } else if (plotType == 1) {
    fPotProfile->SetTitle("Profile plot of the electric field");
    fPotProfile->GetYaxis()->SetTitle("field [V/cm]");
  } else if (plotType == 2) {
    fPotProfile->SetTitle("Profile plot of the electric field (x-component)");
    fPotProfile->GetYaxis()->SetTitle("field [V/cm]");
  } else if (plotType == 3) {
    fPotProfile->SetTitle("Profile plot of the electric field (y-component)");
    fPotProfile->GetYaxis()->SetTitle("field [V/cm]");
  } else if (plotType == 4) {
    fPotProfile->SetTitle("Profile plot of the electric field (z-component)");
    fPotProfile->GetYaxis()->SetTitle("field [V/cm]");
  }
  fPotProfile->SetNpx(nSamples1d);
  fPotProfile->Draw();
  canvas->Update();
}

PlotSurface()

void Garfield::ViewField::PlotSurface

(

const std::string

option = "v"

)

Definition at line 291 of file ViewField.cc.

                                                  {
 
  // Setup the canvas
  if (canvas == 0) {
    canvas = new TCanvas();
    canvas->SetTitle("Field View");
    if (hasExternalCanvas) hasExternalCanvas = false;
  }
  canvas->cd();
  canvas->Range(pxmin, pymin, pxmax, pymax);
 
  if (fPot == 0) CreateFunction();
 
  int plotType = 0;
  if (option == "v" || option == "p" || option == "phi" || option == "volt" ||
      option == "voltage" || option == "pot" || option == "potential") {
    fPot->SetParameter(0, -1.);
    fPot->SetMinimum(fmin);
    fPot->SetMinimum(fmax);
  } else if (option == "e" || option == "field") {
    fPot->SetParameter(0, 1.);
    plotType = 1;
    fPot->SetMinimum(emin);
    fPot->SetMinimum(emax);
  } else if (option == "ex") {
    fPot->SetParameter(0, 11.);
    plotType = 2;
    fPot->SetMinimum(emin);
    fPot->SetMinimum(emax);
  } else if (option == "ey") {
    fPot->SetParameter(0, 21.);
    plotType = 3;
    fPot->SetMinimum(emin);
    fPot->SetMinimum(emax);
  } else if (option == "ez") {
    fPot->SetParameter(0, 31.);
    plotType = 4;
    fPot->SetMinimum(emin);
    fPot->SetMinimum(emax);
  } else {
    std::cerr << className << "::PlotSurface:\n";
    std::cerr << "    Unknown option (" << option << ")\n";
    std::cerr << "    Plotting the potential.\n";
    fPot->SetParameter(0, -1.);
    fPot->SetMinimum(fmin);
    fPot->SetMinimum(fmax);
  }
  fPot->SetNpx(nSamples2dX);
  fPot->SetNpy(nSamples2dY);
  fPot->GetXaxis()->SetTitle(xLabel);
  fPot->GetYaxis()->SetTitle(yLabel);
  if (plotType == 0) {
    fPot->SetTitle("Surface plot of the potential");
  } else if (plotType == 1) {
    fPot->SetTitle("Surface plot of the electric field");
  } else if (plotType == 2) {
    fPot->SetTitle("Surface plot of the electric field (x-component)");
  } else if (plotType == 3) {
    fPot->SetTitle("Surface plot of the electric field (y-component)");
  } else if (plotType == 4) {
    fPot->SetTitle("Surface plot of the electric field (z-component)");
  }
  fPot->Draw("SURF4");
  canvas->Update();
}

PlotSurfaceWeightingField()

void Garfield::ViewField::PlotSurfaceWeightingField	(	const std::string	label,
		const std::string	option
	)

Definition at line 455 of file ViewField.cc.

                                                                  {
 
  // Setup the canvas
  if (canvas == 0) {
    canvas = new TCanvas();
    canvas->SetTitle("Field View");
    if (hasExternalCanvas) hasExternalCanvas = false;
  }
  canvas->cd();
  canvas->Range(pxmin, pymin, pxmax, pymax);
 
  electrode = label;
 
  if (fWfield == 0) CreateFunctionWeightingField();
 
  int plotType = 0;
  if (option == "v" || option == "p" || option == "phi" || option == "volt" ||
      option == "voltage" || option == "pot" || option == "potential") {
    fWfield->SetParameter(0, -1.);
  } else if (option == "e" || option == "field") {
    fWfield->SetParameter(0, 1.);
    plotType = 1;
  } else if (option == "ex") {
    fWfield->SetParameter(0, 11.);
    plotType = 2;
  } else if (option == "ey") {
    fWfield->SetParameter(0, 21.);
    plotType = 3;
  } else if (option == "ez") {
    fWfield->SetParameter(0, 31.);
    plotType = 4;
  } else {
    std::cerr << className << "::PlotSurfaceWeightingField:\n";
    std::cerr << "    Unknown option (" << option << ")\n";
    std::cerr << "    Plotting the absolute value of the field.\n";
    fWfield->SetParameter(0, 1.);
  }
  fWfield->SetNpx(nSamples2dX);
  fWfield->SetNpy(nSamples2dY);
  fWfield->GetXaxis()->SetTitle(xLabel);
  fWfield->GetYaxis()->SetTitle(yLabel);
  if (plotType == 0) {
    fWfield->SetTitle("Surface plot of the weighting potential");
  } else if (plotType == 1) {
    fWfield->SetTitle("Surface plot of the weighting field");
  } else if (plotType == 2) {
    fWfield->SetTitle("Surface plot of the weighting field (x-component)");
  } else if (plotType == 3) {
    fWfield->SetTitle("Surface plot of the weighting field (y-component)");
  } else if (plotType == 4) {
    fWfield->SetTitle("Surface plot of the weighting field (z-component)");
  }
  fWfield->Draw("SURF4");
  canvas->Update();
}

Rotate()

void Garfield::ViewField::Rotate

(

double

angle

)

Definition at line 1085 of file ViewField.cc.

                                         {
 
  // Rotate the axes
  double auxu[3], auxv[3];
  for (int i = 0; i < 3; ++i) {
    auxu[i] = cos(angle) * project[0][i] - sin(angle) * project[1][i];
    auxv[i] = sin(angle) * project[0][i] + cos(angle) * project[1][i];
  }
  for (int i = 0; i < 3; ++i) {
    project[0][i] = auxu[i];
    project[1][i] = auxv[i];
  }
 
  // Make labels to be placed along the axes
  Labels();
}

SetArea()

void Garfield::ViewField::SetArea	(	double	xmin,
		double	ymin,
		double	xmax,
		double	ymax
	)

Definition at line 116 of file ViewField.cc.

                                                                          {
 
  // Check range, assign if non-null
  if (xmin == xmax || ymin == ymax) {
    std::cerr << className << "::SetArea:\n";
    std::cerr << "    Null area range not permitted.\n";
    std::cerr << "      " << xmin << " < x < " << xmax << "\n";
    std::cerr << "      " << ymin << " < y < " << ymax << "\n";
    return;
  }
  pxmin = std::min(xmin, xmax);
  pymin = std::min(ymin, ymax);
  pxmax = std::max(xmin, xmax);
  pymax = std::max(ymin, ymax);
}

SetCanvas()

void Garfield::ViewField::SetCanvas

(

TCanvas *

c

)

Definition at line 105 of file ViewField.cc.

                                    {
 
  if (c == 0) return;
  if (!hasExternalCanvas && canvas != 0) {
    delete canvas;
    canvas = 0;
  }
  canvas = c;
  hasExternalCanvas = true;
}

SetComponent()

void Garfield::ViewField::SetComponent

(

ComponentBase *

c

)

Definition at line 81 of file ViewField.cc.

                                             {
 
  if (c == 0) {
    std::cerr << className << "::SetComponent:\n";
    std::cerr << "    Component pointer is null.\n";
    return;
  }
 
  component = c;
  sensor = 0;
  // Get the bounding box.
  bool ok = component->GetBoundingBox(pxmin, pymin, pzmin, pxmax, pymax, pzmax);
  if (!ok) {
    std::cerr << className << "::SetComponent:\n";
    std::cerr << "    Warning: bounding box of component is not defined.\n";
  }
  // Get the voltage range.
  ok = component->GetVoltageRange(fmin, fmax);
  if (!ok) {
    std::cerr << className << "::SetComponent:\n";
    std::cerr << "    Warning: voltage range of component is not defined.\n";
  }
}

SetDefaultProjection()

void Garfield::ViewField::SetDefaultProjection

(

)

Definition at line 646 of file ViewField.cc.

                                     {
 
  // Default projection: x-y at z=0
  project[0][0] = 1;
  project[1][0] = 0;
  project[2][0] = 0;
  project[0][1] = 0;
  project[1][1] = 1;
  project[2][1] = 0;
  project[0][2] = 0;
  project[1][2] = 0;
  project[2][2] = 0;
 
  // Plane description
  plane[0] = 0;
  plane[1] = 0;
  plane[2] = 1;
  plane[3] = 0;
 
  // Prepare axis labels.
  Labels();
}

Referenced by ViewField().

SetElectricFieldRange()

void Garfield::ViewField::SetElectricFieldRange	(	const double	minval,
		const double	maxval
	)

Definition at line 138 of file ViewField.cc.

                                                           {
 
  emin = std::min(minval, maxval);
  emax = std::max(minval, maxval);
}

SetNumberOfContours()

void Garfield::ViewField::SetNumberOfContours

(

const int

n

)

Definition at line 152 of file ViewField.cc.

                                               {
 
  if (n <= nMaxContours) {
    nContours = n;
  } else {
    std::cerr << className << "::SetNumberOfContours:\n";
    std::cerr << "    Max. number of contours is " << nMaxContours << ".\n";
  }
}

SetNumberOfSamples1d()

void Garfield::ViewField::SetNumberOfSamples1d

(

const int

n

)

Definition at line 162 of file ViewField.cc.

                                                {
 
  const int nmin = 10;
  const int nmax = 100000;
 
  if (n < nmin || n > nmax) {
    std::cerr << className << "::SetNumberOfSamples1d:\n";
    std::cerr << "    Number of points (" << n << ") out of range.\n";
    std::cerr << "    " << nmin << " <= n <= " << nmax << "\n";
    return;
  }
 
  nSamples1d = n;
}

SetNumberOfSamples2d()

void Garfield::ViewField::SetNumberOfSamples2d	(	const int	nx,
		const int	ny
	)

Definition at line 177 of file ViewField.cc.

                                                               {
 
  const int nmin = 10;
  const int nmax = 10000;
  if (nx < nmin || nx > nmax) {
    std::cerr << className << "::SetNumberOfSamples2d:\n";
    std::cerr << "    Number of x-points (" << nx << ") out of range.\n";
    std::cerr << "    " << nmin << " <= nx <= " << nmax << "\n";
  } else {
    nSamples2dX = nx;
  }
 
  if (ny < nmin || ny > nmax) {
    std::cerr << className << "::SetNumberOfSamples2d:\n";
    std::cerr << "    Number of y-points (" << ny << ") out of range.\n";
    std::cerr << "    " << nmin << " <= ny <= " << nmax << "\n";
  } else {
    nSamples2dY = ny;
  }
}

SetPlane()

void Garfield::ViewField::SetPlane	(	double	fx,
		double	fy,
		double	fz,
		double	x0,
		double	y0,
		double	z0
	)

Definition at line 1044 of file ViewField.cc.

                                                                            {
 
  // Calculate 2 in-plane vectors for the normal vector
  double fnorm = sqrt(fx * fx + fy * fy + fz * fz);
  if (fnorm > 0 && fx * fx + fz * fz > 0) {
    project[0][0] = fz / sqrt(fx * fx + fz * fz);
    project[0][1] = 0;
    project[0][2] = -fx / sqrt(fx * fx + fz * fz);
    project[1][0] = -fx * fy / (sqrt(fx * fx + fz * fz) * fnorm);
    project[1][1] = (fx * fx + fz * fz) / (sqrt(fx * fx + fz * fz) * fnorm);
    project[1][2] = -fy * fz / (sqrt(fx * fx + fz * fz) * fnorm);
    project[2][0] = x0;
    project[2][1] = y0;
    project[2][2] = z0;
  } else if (fnorm > 0 && fy * fy + fz * fz > 0) {
    project[0][0] = (fy * fy + fz * fz) / (sqrt(fy * fy + fz * fz) * fnorm);
    project[0][1] = -fx * fz / (sqrt(fy * fy + fz * fz) * fnorm);
    project[0][2] = -fy * fz / (sqrt(fy * fy + fz * fz) * fnorm);
    project[1][0] = 0;
    project[1][1] = fz / sqrt(fy * fy + fz * fz);
    project[1][2] = -fy / sqrt(fy * fy + fz * fz);
    project[2][0] = x0;
    project[2][1] = y0;
    project[2][2] = z0;
  } else {
    std::cout << className << "::SetPlane:\n";
    std::cout << "    Normal vector has zero norm.\n";
    std::cout << "    No new projection set.\n";
  }
 
  // Store the plane description
  plane[0] = fx;
  plane[1] = fy;
  plane[2] = fz;
  plane[3] = fx * x0 + fy * y0 + fz * z0;
 
  // Make labels to be placed along the axes
  Labels();
}

SetSensor()

void Garfield::ViewField::SetSensor

(

Sensor *

s

)

Definition at line 57 of file ViewField.cc.

                                   {
 
  if (s == 0) {
    std::cerr << className << "::SetSensor:\n";
    std::cerr << "    Sensor pointer is null.\n";
    return;
  }
 
  sensor = s;
  component = 0;
  // Get the bounding box.
  bool ok = sensor->GetArea(pxmin, pymin, pzmin, pxmax, pymax, pzmax);
  if (!ok) {
    std::cerr << className << "::SetSensor:\n";
    std::cerr << "    Warning: bounding box of sensor is not defined.\n";
  }
  // Get the voltage range.
  ok = sensor->GetVoltageRange(fmin, fmax);
  if (!ok) {
    std::cerr << className << "::SetSensor:\n";
    std::cerr << "    Warning: voltage range of sensor is not defined.\n";
  }
}

SetVoltageRange()

void Garfield::ViewField::SetVoltageRange	(	const double	minval,
		const double	maxval
	)

Definition at line 132 of file ViewField.cc.

                                                                        {
 
  fmin = std::min(minval, maxval);
  fmax = std::max(minval, maxval);
}

SetWeightingFieldRange()

void Garfield::ViewField::SetWeightingFieldRange	(	const double	minval,
		const double	maxval
	)

Definition at line 145 of file ViewField.cc.

                                                            {
 
  wmin = std::min(minval, maxval);
  wmax = std::max(minval, maxval);
}

---

The documentation for this class was generated from the following files:

• ViewField.hh
• ViewField.cc