ViewMedium.hh

Go to the documentation of this file.

#ifndef G_VIEW_MEDIUM
#define G_VIEW_MEDIUM
 
#include <array>
#include <string>
#include <vector>
 
#include "Garfield/FundamentalConstants.hh"
#include "Garfield/ViewBase.hh"
 
namespace Garfield {
 
class Medium;

 
class ViewMedium : public ViewBase {
 public:
  ViewMedium() : ViewMedium(nullptr) {}
  ViewMedium(Medium* medium);
  ~ViewMedium() = default;

  void SetMedium(Medium* m);

  void EnableAutoRangeX(const bool on = true) { m_autoRangeX = on; }
  void SetRangeE(const double emin, const double emax, const bool logscale);
  void SetRangeB(const double bmin, const double bmax, const bool logscale);
  void SetRangeA(const double amin, const double amax, const bool logscale);
  void SetRangeEN(const double emin, const double emax, const bool logscale);
  void SetRangeEP(const double emin, const double emax, const bool logscale);
  void EnableAutoRangeY(const bool on = true) { m_autoRangeY = on; }
  void SetRangeY(const double ymin, const double ymax,
                 const bool logscale = false);

  void SetElectricField(const double efield) { m_efield = efield; }
  void SetMagneticField(const double bfield) { m_bfield = bfield; }
  void SetAngle(const double angle) { m_angle = angle; }
 
  void EnableExport(const std::string& txtfile) { m_outfile = txtfile; }
  void DisableExport() { m_outfile = ""; }

  void PlotVelocity(const std::string& carriers, const char xaxis);
  void PlotDiffusion(const std::string& carriers, const char xaxis);
  void PlotTownsend(const std::string& carriers, const char xaxis);
  void PlotAttachment(const std::string& carriers, const char xaxis);
  void PlotAlphaEta(const std::string& carriers, const char xaxis);

  void PlotElectronVelocity(const char xaxis = 'e', const bool same = false) {
    PlotVelocity(GetAxis(xaxis), Charge::Electron, same);
  }

  void PlotElectronVelocityFluxBulk(const char xaxis = 'e',
                                    const bool same = false) {
    PlotVelocityFluxBulk(GetAxis(xaxis), Charge::Electron, same);
  }

  void PlotHoleVelocity(const char xaxis = 'e', const bool same = false) {
    PlotVelocity(GetAxis(xaxis), Charge::Hole, same);
  }

  void PlotIonVelocity(const char xaxis = 'e', const bool same = false) {
    PlotVelocity(GetAxis(xaxis), Charge::Ion, same);
  }

  void PlotElectronDiffusion(const char xaxis = 'e', const bool same = false) {
    PlotDiffusion(GetAxis(xaxis), Charge::Electron, same);
  }

  void PlotHoleDiffusion(const char xaxis = 'e', const bool same = false) {
    PlotDiffusion(GetAxis(xaxis), Charge::Hole, same);
  }

  void PlotIonDiffusion(const char xaxis = 'e', const bool same = false) {
    PlotDiffusion(GetAxis(xaxis), Charge::Ion, same);
  }

  void PlotElectronTownsend(const char xaxis = 'e', const bool same = false) {
    Plot(GetAxis(xaxis), Charge::Electron, Parameter::Townsend, same);
  }

  void PlotElectronReducedTownsendN(const char xaxis = 'r',
                                    const bool same = false) {
    Plot(GetAxis(xaxis), Charge::Electron, Parameter::AlphaN, same);
  }

  void PlotElectronReducedTownsendP(const char xaxis = 'p',
                                    const bool same = false) {
    Plot(GetAxis(xaxis), Charge::Electron, Parameter::AlphaP, same);
  }

  void PlotElectronTOFIonization(const char xaxis = 'e',
                                 const bool same = false) {
    Plot(GetAxis(xaxis), Charge::Electron, Parameter::RIonTof, same);
  }

  void PlotHoleTownsend(const char xaxis = 'e', const bool same = false) {
    Plot(GetAxis(xaxis), Charge::Hole, Parameter::Townsend, same);
  }

  void PlotElectronAttachment(const char xaxis = 'e', const bool same = false) {
    Plot(GetAxis(xaxis), Charge::Electron, Parameter::Attachment, same);
  }

  void PlotElectronTOFAttachment(const char xaxis = 'e',
                                 const bool same = false) {
    Plot(GetAxis(xaxis), Charge::Electron, Parameter::RAttTof, same);
  }

  void PlotHoleAttachment(const char xaxis = 'e', const bool same = false) {
    Plot(GetAxis(xaxis), Charge::Hole, Parameter::Attachment, same);
  }

  void PlotElectronLorentzAngle(const char xaxis = 'e',
                                const bool same = false) {
    PlotLorentzAngle(GetAxis(xaxis), Charge::Electron, same);
  }

  void SetColours(const std::vector<short>& cols) { m_colours = cols; }
  void SetLabels(const std::vector<std::string>& labels) { m_labels = labels; }
 
 private:
  enum class Parameter {
    VelocityE,
    VelocityB,
    VelocityExB,
    VelocityWv,
    VelocityWr,
    TransverseDiffusion,
    LongitudinalDiffusion,
    Townsend,
    Attachment,
    LorentzAngle,
    RIonTof,
    RAttTof,
    AlphaN,
    AlphaP
  };
 
  enum class Charge { Electron, Hole, Ion };
 
  enum class Axis { E, B, Angle, EoverN, EoverP, None };
 
  Medium* m_medium = nullptr;
 
  // X axis
  double m_eMin = 100., m_eMax = 100000.;
  double m_bMin = 0., m_bMax = 2.;
  double m_aMin = 0., m_aMax = Pi;
  double m_enMin = 0.25, m_enMax = 400.;
  double m_epMin = 0.13, m_epMax = 132.;
  bool m_logE = true;
  bool m_logB = false;
  bool m_logA = false;
  bool m_logEN = true;
  bool m_logEP = true;
  bool m_logX = true;
  bool m_autoRangeX = true;
  Axis m_xaxis = Axis::None;
 
  // Y axis
  double m_yMin = 0., m_yMax = 1.;
  bool m_logY = false;
  bool m_autoRangeY = true;
 
  // E-field to use when plotting as function of B-field or angle.
  double m_efield = 1000.;
  // B-field to use when plotting as function of E-field or angle.
  double m_bfield = 0.;
  // Angle to use when plotting as function of E-field or B-field.
  double m_angle = HalfPi;
 
  std::vector<double> m_xPlot;
  std::vector<std::vector<double> > m_yPlot;
  std::vector<Parameter> m_par;
  std::vector<Charge> m_q;
 
  std::vector<std::vector<double> > m_xGraph;
  std::vector<std::vector<double> > m_yGraph;
 
  std::vector<short> m_colours;
  std::vector<std::string> m_labels;
 
  std::string m_outfile;
 
  void PlotVelocity(const Axis xaxis, const Charge particle, const bool same);
  void PlotVelocityFluxBulk(const Axis xaxis, const Charge particle,
                            const bool same);
  void PlotDiffusion(const Axis xaxis, const Charge particle, const bool same);
  void Plot(const Axis xaxis, const Charge particle, const Parameter par,
            const bool same);
  void PlotLorentzAngle(const Axis xaxis, const Charge particle,
                        const bool same);
 
  void ResetY();
  void ResetX(const Axis xaxis);
  void Draw();
  void Export();
 
  Axis GetAxis(const char xaxis) const;
  bool GetGrid(std::array<std::vector<double>, 3>& grid, int& ie, int& ib,
               int& ia, const Axis xaxis) const;
 
  double ConvertToEN(const double e0Vcm);
  double UnConvertFromEN(const double e0Td);
  double ConvertToEP(const double e0Vcm);
  double UnConvertFromEP(const double e0VcmTorr);
};
}  // namespace Garfield
#endif