GeFiCa::Grid Class Reference

Data structure of a electric field grid. More...

#include <Grid.h>

Inheritance diagram for GeFiCa::Grid:

Collaboration diagram for GeFiCa::Grid:

Public Member Functions
	Grid (size_t n1=0, size_t n2=0, size_t n3=0)
	Default constructor. More...
virtual	~Grid ()
virtual void	SetupWith (Detector &detector)
	Fix potentials on boundaries based on. More...
void	SuccessiveOverRelax ()
	Successively over-relax potentials on grid points. More...
void	SolveAnalytically ()
	Solve Poisson's Equation analytically. More...
double	GetV (double c1, double c2=0, double c3=0) const
	Get potential at (c1,c2,c3) by interpolation. More...
double	GetE (double c1, double c2=0, double c3=0) const
double	GetE1 (double c1, double c2=0, double c3=0) const
double	GetE2 (double c1, double c2=0, double c3=0) const
double	GetE3 (double c1, double c2=0, double c3=0) const
double	GetC ()
	Get detector capacitance. More...
TTree *	GetTree (bool createNew=false)
	Create &/or return a TTree with field data. More...
bool	IsDepleted ()
	Check if every grid point is depleted. More...
Grid &	operator*= (double scale)
	Potentials at all points are multiplied by. More...
Grid &	operator+= (Grid &other)
	Potentials of this grid are summed with those of. More...
virtual FieldLine *	GetFieldLineFrom (double c1, double c2, bool positive=true)
	Propogate a field line from (c1,c2,c3). More...
virtual FieldLine *	GetFieldLineFrom (double c1, double c2, double c3, bool positive=true)
Public Member Functions inherited from GeFiCa::Points
size_t	GetN ()
	total number of points More...

Public Attributes
size_t	N1
	number of points along the 1st coordinate More...
size_t	N2
	number of points along the 2nd coordinate More...
size_t	N3
	number of points along the 3rd coordinate More...
std::vector< double >	Src
	-(net impurity concentration)x|Qe|/epsilon More...
size_t	MaxIterations
	maximal iterations of SOR to be performed More...
double	RelaxationFactor
	within (0,2), used to speed up convergence More...
double	Tolerance
	SOR stops when error<Tolerance. More...
size_t	Iterations
	number of iterations of SOR performed More...
Public Attributes inherited from GeFiCa::Points
std::vector< double >	C1
	the 1st coordinates of the points More...
std::vector< double >	C2
	the 2nd coordinates of the points More...
std::vector< double >	C3
	the 3rd coordinates of the points More...
std::vector< double >	Vp
	potential at each point More...
std::vector< double >	Et
	total electric field strength More...
std::vector< double >	E1
	projection of Et on C1 More...
std::vector< double >	E2
	projection of Et on C2 More...
std::vector< double >	E3
	projection of Et on C3 More...
std::vector< double >	dC1p
	step length to next point alone C1 More...
std::vector< double >	dC1m
	step length to previous point alone C1 More...
std::vector< double >	dC2p
	step length to next point along C2 More...
std::vector< double >	dC2m
	step length to previous point along C2 More...
std::vector< double >	dC3p
	step length to next point alone C3 More...
std::vector< double >	dC3m
	step length to previous point alone C3 More...

Protected Member Functions
virtual void	OverRelaxAt (size_t idx)
	Over relax potential Vp[. More...
size_t	GetIdxOfPointToTheRightOf (double c1, size_t begin, size_t end) const
	Get index of point near. More...
size_t	GetIdxOfPointToTheRightOf (double c1, double c2, size_t begin, size_t end) const
size_t	GetIdxOfPointToTheRightOf (double c1, double c2, double c3, size_t begin, size_t end) const
virtual double	GetData (const std::vector< double > &data, double c1, double c2, double c3) const
	Interpolate grid data at (c1,c2,c3). More...
size_t	GetIdxOfMaxV ()
	Get index of the grid point with max potential. More...
size_t	GetIdxOfMinV ()
	Get index of the grid point with min potential. More...
virtual void	CalculateE ()
	Calculate Et, E1, E2, E3 from Vp. More...
double	twopoint (double dataset[2], double tarlocationset, double pointxset[2]) const
	Calculate interpolation value between two point. More...
double	threepoint (double dataset[3], double tarlocationset[2], double pointxset[3], double pointyset[3]) const
	Calculate interpolation value between three point (triangle) More...
double	fourpoint (double dataset[4], double tarlocationset[2], double pointxset[4], double pointyset[4]) const
	Calculate interpolation value between four point (rectangle) More...
	ClassDef (Grid, 1)

Protected Attributes
std::vector< bool >	fIsFixed
	true if field values are fixed More...
std::vector< bool >	fIsDepleted
	true if a grid point is depleted More...
TTree *	fTree
	! ROOT tree to visualize fields More...
Detector *	fDetector
	! Pointer to associated detector object More...

Detailed Description

Data structure of a electric field grid.

It inherits the flat data structure from Points instead of using the class to save typing. Compare C1[i] with point.C1[i].

Definition at line 50 of file Grid.h.

Constructor & Destructor Documentation

Grid()

Grid::Grid	(	size_t	n1 = 0,
		size_t	n2 = 0,
		size_t	n3 = 0
	)

Default constructor.

It also defines ROOT drawing style.

Definition at line 26 of file Grid.cc.

                                          : Points(), TNamed("grid","grid"),
   N1(n1), N2(n2), N3(n3), MaxIterations(5000), RelaxationFactor(1.95),
   Tolerance(1e-7*volt), Iterations(0), fTree(0), fDetector(0)
{
   // pick up a good style to modify
   gStyle->SetName("GeFiCa");
   gStyle->SetLegendBorderSize(0);
   gStyle->SetLegendFont(132);
   gStyle->SetLabelFont(132,"XYZ");
   gStyle->SetTitleFont(132,"XYZ");
   gStyle->SetLabelSize(0.05,"XYZ");
   gStyle->SetTitleSize(0.05,"XYZ");
   gStyle->SetPadTopMargin(0.02);
   // create a smoother palette than the default one
   const int nRGBs = 5;
   const int nCont = 255;
   double stops[nRGBs] = { 0.00, 0.34, 0.61, 0.84, 1.00 };
   double red[nRGBs]   = { 0.00, 0.00, 0.87, 1.00, 0.51 };
   double green[nRGBs] = { 0.00, 0.81, 1.00, 0.20, 0.00 };
   double blue[nRGBs]  = { 0.51, 1.00, 0.12, 0.00, 0.00 };
   TColor::CreateGradientColorTable(nRGBs, stops, red, green, blue, nCont);
   gStyle->SetNumberContours(nCont);
}

~Grid()

virtual GeFiCa::Grid::~Grid ( )

inlinevirtual

Definition at line 66 of file Grid.h.

{};

Member Function Documentation

CalculateE()

void Grid::CalculateE ( )

protectedvirtual

Calculate Et, E1, E2, E3 from Vp.

Reimplemented in GeFiCa::RhoZ, GeFiCa::XYZ, GeFiCa::RhoPhi, and GeFiCa::RTheta.

Definition at line 551 of file Grid.cc.

{
   for (size_t i=0; i<GetN(); i++) { // deal with E1 only
      E1[i]=-(Vp[i+1]-Vp[i-1])/(dC1p[i]+dC1m[i]); Et[i]=E1[i];
   }
   E1[0]=-(Vp[1]-Vp[0])/dC1p[0]; Et[0]=E1[0];
   E1[N1-1]=-(Vp[N1-1]-Vp[N1-2])/dC1m[N1-1]; Et[N1-1]=E1[N1-1];
}

ClassDef()

GeFiCa::Grid::ClassDef ( Grid  , 1    )

protected

fourpoint()

double Grid::fourpoint ( double  dataset[4], double  tarlocationset[2], double  pointxset[4], double  pointyset[4]  ) const

protected

Calculate interpolation value between four point (rectangle)

Definition at line 604 of file Grid.cc.

{
   //0---------1
   //|         |
   //|         |
   //|         |
   //2---------3
   double ab=(pointxset[1]-tarlocationset[0])/(pointxset[1]-pointxset[0]);
   double aa=1-ab;
   double ba=(tarlocationset[1]-pointyset[3])/(pointyset[1]-pointyset[3]);
   double bb=1-ba;

   double result=(dataset[1]*aa+dataset[0]*ab)*ba+(dataset[2]*ab+dataset[3]*aa)*bb;
   delete [] dataset;
   delete [] tarlocationset;
   delete [] pointxset;
   delete [] pointyset;

   if (TMath::Abs(result)<1e-10) return 0;
   return result;
}

GetC()

double Grid::GetC

(

)

Get detector capacitance.

Calculate C based on \(CV^2/2 = \epsilon \int E^2/2 dx^3\). http://hyperphysics.phy-astr.gsu.edu/hbase/electric/capeng.html

Definition at line 198 of file Grid.cc.

{
   Info("GetC","Start...");
   SuccessiveOverRelax(); // identify undepleted region
   std::vector<double>original=Src; // save original rho/epsilon
   for (size_t i=0; i<GetN(); i++) {
      Src[i]=0; // set impurity to zero
      if (fIsDepleted[i]==false) fIsFixed[i]=true; // fix undepleted points
   }
   SuccessiveOverRelax(); // calculate potential without impurity
   Src=original; // set impurity back

   return 0;
}

GetData()

double Grid::GetData ( const std::vector< double > &  data, double  c1, double  c2, double  c3  ) const

protectedvirtual

Interpolate grid data at (c1,c2,c3).

Definition at line 260 of file Grid.cc.

{
   if (N3!=0) { // 3D
      Warning("GetData", "not yet implemented. Abort."); abort();
   }
   if (N2!=0) { // 2D
      // https://codeplea.com/triangular-interpolation
      //       tmv
      // +-aa--+--ab--+(C1[idx], C2[idx])
      // |     ^      |
      // |  dyp|      ba
      // |     |(x,y) |
      // +<----+----->+
      // |     |      |
      // |  dym|      bb
      // |     v      |
      // +-----+------+
      //       bmv
      size_t idx=GetIdxOfPointToTheRightOf(x,y,0,N2-1); // always exists

      bool tl=false; // existence of top left grid point
      bool br=false; // existence of bottom right grid point
      bool bl=false; // existence of bottom left grid point
      if (idx%N1!=0) tl=true; // not left boundary
      if (idx>=N1) br=true; // not bottom boundary
      if (tl&&bl) bl=true; // neither left nor bottom boundary

      if(!tl&&!br&&!bl) { // bottom left corner
         return data[idx];
      } else if(tl&&!br&&!bl) { // bottom boundary
         return twopoint(new double[2] {data[idx-1],data[idx]},
               x,new double[2] {C1[idx-1],C1[idx]});
      } else if(!tl&&!bl&&br) { // left boundary
         return twopoint(new double[2]{data[idx-N1],data[idx]},
               y,new double[2]{C2[idx-N1],C2[idx]});
      }
      // no boundary case
      if(dC1p[idx-1]==dC1m[idx]&&dC1p[idx-N1-1]==dC1m[idx-N1]&&
            dC2p[idx-N1-1]==dC2m[idx-1]&&dC2p[idx-N1]==dC2m[idx]) {
         return fourpoint(new double[4]{data[idx-1],data[idx],data[idx-N1-1],data[idx-N1]},new double[2]{x,y},new double[4]{C1[idx-1],C1[idx],C1[idx-N1-1],C1[idx-N1]},new double[4]{C2[idx-1],C2[idx],C2[idx-N1-1],C2[idx-N1]});
      }

      //top left case o
      if(dC1p[idx-1]!=dC1m[idx]&&
            dC1p[idx-N1-1]==dC1m[idx-N1]&&
            dC2p[idx-N1-1]!=dC2m[idx-1]&&
            dC2p[idx-N1]==dC2m[idx])
      {
         double xb=dC1m[idx]<dC1p[idx-1] ? C1[idx]-dC1m[idx] : C1[idx-1]+dC1p[idx-1];
         double yb=dC2m[idx-1]<dC2p[idx-N1-1] ? C2[idx-1]-dC2m[idx-1] : C2[idx-N1-1]+dC2p[idx-N1-1];
         double bmv=(C1[idx-N1]-xb)/(C1[idx-N1]-C1[idx-N1-1])*data[idx-N1-1]+(xb-C1[idx-N1-1])/(C1[idx-N1]-C1[idx-N1-1])*data[idx-N1];
         double tmv=fIsFixed[idx]?data[idx]:data[idx-1];
         double mlv=fIsFixed[idx-1]?data[idx-1]:data[idx-N1-1];
         double mmv=(C2[idx]-yb)/(C2[idx]-C2[idx-N1])*bmv+(yb-C2[idx-N1])/(C2[idx]-C2[idx-N1])*tmv;
         if(x>xb)
         {
            return fourpoint(new double[4]{tmv,data[idx],bmv,data[idx-N1]},new double[2]{x,y},new double[4]{xb,C1[idx],xb,C1[idx-N1]},new double[4]{C2[idx],C2[idx],C2[idx-N1],C2[idx-N1]});
         }
         else if(y<yb)
         {
            return fourpoint(new double[4]{mlv,mmv,data[idx-N1-1],bmv},new double[2]{x,y},new double[4]{C1[idx-1],xb,C1[idx-1],xb},new double[4]{yb,yb,C2[idx-N1],C2[idx-N1]});
         }
         else if((C2[idx]-yb)/(xb-C1[idx-1]*(x-C1[idx-1])+yb>y))
         {
            return threepoint(new double[3]{tmv,mmv,mlv},new double[2]{x,y},new double[3]{xb,xb,C1[idx-1]},new double[3]{C2[idx],yb,yb});
         }
         else if((C2[idx]-yb)/(xb-C1[idx-1]*(x-C1[idx-1])+yb<y))
         {
            return threepoint(new double[3]{tmv,tmv,mlv},new double[2]{x,y},new double[3]{xb,C1[idx-1],C1[idx-1]},new double[3]{C2[idx],C2[idx],yb});
         }
      }
      //topright case o
      if(dC1p[idx-1]!=dC1m[idx]&&
            dC1p[idx-N1-1]==dC1m[idx-N1]&&
            dC2p[idx-N1-1]==dC2m[idx-1]&&
            dC2p[idx-N1]!=dC2m[idx])
      {
         double xb=dC1m[idx]<dC1p[idx-1] ? C1[idx]-dC1m[idx] : C1[idx-1]+dC1p[idx-1];
         double yb=dC2m[idx]<dC2p[idx-N1] ? C2[idx]-dC2m[idx] : C2[idx-N1]+dC2p[idx-N1];
         double bmv=(C1[idx-N1]-xb)/(C1[idx-N1]-C1[idx-N1-1])*data[idx-N1-1]+(xb-C1[idx-N1-1])/(C1[idx-N1]-C1[idx-N1-1])*data[idx-N1];
         double tmv=fIsFixed[idx]?data[idx]:data[idx-1];
         double mrv=fIsFixed[idx]?data[idx]:data[idx-N1];
         double mmv=(C2[idx]-yb)/(C2[idx]-C2[idx-N1])*bmv+(yb-C2[idx-N1])/(C2[idx]-C2[idx-N1])*tmv;
         if(x<xb)
         {
            return fourpoint(new double[4]{data[idx-1],tmv,data[idx-N1-1],bmv},new double[2]{x,y},new double[4]{C1[idx-1],xb,C1[idx-N1-1],xb},new double[4]{C2[idx],C2[idx],C2[idx-N1],C2[idx-N1]});
         }
         else if(y<yb)
         {
            return fourpoint(new double[4]{mmv,mrv,bmv,data[idx-N1]},new double[2]{x,y},new double[4]{xb,C1[idx],xb,C1[idx-1]},new double[4]{yb,yb,C2[idx-N1],C2[idx-N1]});
         }
         else if((C2[idx]-yb)/(C1[idx]-x*(x-C1[idx])+yb>y))
         {
            return threepoint(new double[3]{tmv,mmv,mrv},new double[2]{x,y},new double[3]{xb,xb,C1[idx]},new double[3]{C2[idx],yb,yb});
         }
         else if((C2[idx]-yb)/(C1[idx]-xb*(x-C1[idx])+yb<y))
         {
            return threepoint(new double[3]{tmv,data[idx],mrv},new double[2]{x,y},new double[3]{xb,C1[idx],C1[idx]},new double[3]{C2[idx],C2[idx],yb});
         }
      }
      //bottom left case o
      if(dC1p[idx-1]==dC1m[idx]&&
            dC1p[idx-N1-1]!=dC1m[idx-N1]&&
            dC2p[idx-N1-1]!=dC2m[idx-1]&&
            dC2p[idx-N1]==dC2m[idx])
      {
         double xb=dC1m[idx-N1]<dC1p[idx-N1-1] ? C1[idx-N1]-dC1m[idx-N1] : C1[idx-N1-1]+dC1p[idx-N1-1];
         double yb=dC2m[idx-1]<dC2p[idx-N1-1] ? C2[idx-1]-dC2m[idx-1] : C2[idx-N1-1]+dC2p[idx-N1-1];
         double tmv=(C1[idx]-xb)/(C1[idx]-C1[idx-1])*data[idx-1]+(xb-C1[idx-1])/(C1[idx]-C1[idx-1])*data[idx];
         double bmv=fIsFixed[idx]?data[idx]:data[idx-1];
         double mlv=fIsFixed[idx-1]?data[idx-1]:data[idx-N1-1];
         double mmv=(C2[idx]-yb)/(C2[idx]-C2[idx-N1])*bmv+(yb-C2[idx-N1])/(C2[idx]-C2[idx-N1])*tmv;
         if(x>xb)
         {
            return fourpoint(new double[4]{tmv,data[idx],bmv,data[idx-N1]},new double[2]{x,y},new double[4]{xb,C1[idx],xb,C1[idx-N1]},new double[4]{C2[idx],C2[idx],C2[idx-N1],C2[idx-N1]});
         }
         else if(y>yb)
         {
            return fourpoint(new double[4]{data[idx-N1-1],tmv,mlv,mmv},new double[2]{x,y},new double[4]{C1[idx-1],xb,C1[idx-1],xb},new double[4]{C2[idx],C2[idx],yb,yb});
         }
         else if((C2[idx]-yb)/(xb-C1[idx-1]*(x-C1[idx-1])+C2[idx-N1]>y))
         {
            return threepoint(new double[3]{bmv,mmv,mlv},new double[2]{x,y},new double[3]{xb,xb,C1[idx-1]},new double[3]{yb,yb,C2[idx-N1]});
         }
         else if((C2[idx]-yb)/(xb-C1[idx-1]*(x-C1[idx-1])+C2[idx-N1]<y))
         {
            return threepoint(new double[3]{data[idx-N1-1],bmv,mlv},new double[2]{x,y},new double[3]{C1[idx-1],xb,C1[idx-1]},new double[3]{C2[idx],C2[idx],yb});
         }
      }
      //bottom right case o
      if(dC1p[idx-1]==dC1m[idx]&&
            dC1p[idx-N1-1]!=dC1m[idx-N1]&&
            dC2p[idx-N1-1]==dC2m[idx-1]&&
            dC2p[idx-N1]!=dC2m[idx])
      {
         double xb=dC1m[idx-N1]<dC1p[idx-N1-1] ? C1[idx-N1]-dC1m[idx-N1] : C1[idx-N1-1]+dC1p[idx-N1-1];
         double yb=dC2m[idx]<dC2p[idx-N1] ? C2[idx]-dC2m[idx] : C2[idx-N1]+dC2p[idx-N1];
         double tmv=(C1[idx]-xb)/(C1[idx]-C1[idx-1])*data[idx-1]+(xb-C1[idx-1])/(C1[idx]-C1[idx-1])*data[idx];
         double bmv=fIsFixed[idx-N1]?data[idx-N1]:data[idx-N1-1];
         double mrv=fIsFixed[idx-N1]?data[idx-N1]:data[idx];
         double mmv=(C2[idx]-yb)/(C2[idx]-C2[idx-N1])*bmv+(yb-C2[idx-N1])/(C2[idx]-C2[idx-N1])*tmv;
         if(x<xb)
         {
            return fourpoint(new double[4]{data[idx-1],tmv,data[idx-N1-1],bmv},new double[2]{x,y},new double[4]{C1[idx-1],xb,C1[idx-N1-1],xb},new double[4]{C2[idx],C2[idx],C2[idx-N1],C2[idx-N1]});
         }
         else if(y>yb)
         {
            return fourpoint(new double[4]{tmv,data[idx],mmv,mrv},new double[2]{x,y},new double[4]{xb,C1[idx],xb,C1[idx]},new double[4]{C2[idx],C2[idx],yb,yb});
         }
         else if((yb-C2[idx-N1])/(C1[idx]-xb*(x-xb)+C2[idx-N1]>y))
         {
            return threepoint(new double[3]{bmv,mmv,mrv},new double[2]{x,y},new double[3]{xb,xb,C1[idx]},new double[3]{C2[idx-N1],yb,yb});
         }
         else if((yb-C2[idx-N1])/(C1[idx]-xb*(x-xb)+C2[idx-N1]<=y))
         {
            return threepoint(new double[3]{bmv,data[idx-N1],mrv},new double[2]{x,y},new double[4]{xb,C1[idx],C1[idx-1]},new double[4]{C2[idx-N1],C2[idx-N1],yb});
         }
      }
      //cross top down case o
      if(dC1p[idx-1]!=dC1m[idx]&&
            dC1p[idx-N1-1]!=dC1m[idx-N1]&&
            dC2p[idx-N1-1]==dC2m[idx-1]&&
            dC2p[idx-N1]==dC2m[idx])
      {
         double topb=dC1m[idx]<dC1p[idx-1] ? C1[idx]-dC1m[idx] : C1[idx-1]+dC1p[idx-1];
         double bottomb=dC1m[idx-N1]<dC1p[idx-N1-1] ? C1[idx-N1]-dC1m[idx-N1] : C1[idx-N1-1]+dC1p[idx-N1-1];
         double bmv=fIsFixed[idx-N1]?data[idx-N1]:data[idx-N1-1];
         double tmv=fIsFixed[idx]?data[idx]:data[idx-1];
         double TopValueWithBottomCorssPoint=topb>bottomb ? (topb-bottomb)/(topb-C1[idx-1])*data[idx-1]+(bottomb-C1[idx-1])/(topb-C1[idx-1])*tmv : 
            (bottomb-topb)/(C1[idx]-topb)*data[idx]+(C1[idx]-bottomb)/(C1[idx-1]-topb)*tmv ;
         double BottomValueWithTopCorssPoint=topb>bottomb ? (topb-bottomb)/(C1[idx-N1]-bottomb)*bmv+(C1[idx-N1]-topb)/(C1[idx-N1]-bottomb)*data[idx-N1] : 
            (topb-C1[idx-N1-1])/(bottomb-C1[idx-N1-1])*bmv+(bottomb-topb)/(bottomb-C1[idx-1-N1])*data[idx-N1-1] ;
         double TopLeft,TopRight,BottomLeft,BottomRight;
         double TopLeftV,TopRightV,BottomLeftV,BottomRightV;
         if(topb>bottomb) {
            TopLeft=bottomb;
            TopLeftV=TopValueWithBottomCorssPoint;
            TopRight=topb;
            TopRightV=tmv;
            BottomLeft=bottomb;
            BottomLeftV=bmv;
            BottomRight=topb;
            BottomRightV=BottomValueWithTopCorssPoint;
         } else {
            TopRight=bottomb;
            TopRightV=TopValueWithBottomCorssPoint;
            TopLeft=topb;
            TopLeftV=tmv;
            BottomRight=bottomb;
            BottomRightV=bmv;
            BottomLeft=topb;
            BottomLeftV=BottomValueWithTopCorssPoint;
         }
         if(x>TopRight) {
         if(x<1.185&&x>1.175&&y>4.915&&y<4.925)Printf("trv:%f,brv:%f",TopRightV,BottomRightV);
            return fourpoint(new double[4]{TopRightV,data[idx],BottomRightV,data[idx-N1]},
                  new double[2]{x,y},new double[4]{TopRight,C1[idx],BottomRight,C1[idx-N1]},
                  new double[4]{C2[idx],C2[idx],C2[idx-N1],C2[idx-N1]});
         } else if(x<TopLeft) {
            return fourpoint(new double[4]{data[idx-1],TopLeftV,data[idx-N1-1],BottomLeftV},
                  new double[2]{x,y},new double[4]{C1[idx-1],TopLeft,C1[idx-N1-1],BottomLeft},
                  new double[4]{C2[idx-1],C2[idx-1],C2[idx-N1-1],C2[idx-N1-1]});
         } else if((dC2m[idx])/((topb-bottomb)*(x-(TopRight-TopLeft)/2)+C2[idx-N1]>y-dC2m[idx]/2)) {
            return topb>bottomb ? threepoint(new double[3]{TopRightV,BottomLeftV,BottomRightV},new double[2]{x,y},new double[3]{TopRight,BottomLeft,BottomRight},new double[3]{C2[idx],C2[idx-N1],C2[idx-N1]}) :
               threepoint(new double[3]{TopLeft,BottomLeftV,BottomRightV},new double[2]{x,y},new double[3]{TopLeft,BottomLeft,BottomRight},new double[3]{C2[idx],C2[idx-N1],C2[idx-N1]});
         } else if((dC2m[idx])/((topb-bottomb)*(x-(TopRight-TopLeft)/2)+C2[idx-N1]<=y-dC2m[idx]/2)) {
            return topb<bottomb ? threepoint(new double[3]{TopRightV,TopLeftV,BottomRightV},new double[2]{x,y},new double[3]{TopRight,TopLeft,BottomRight},new double[3]{C2[idx],C2[idx],C2[idx-N1]}) :
               threepoint(new double[3]{TopLeft,TopLeftV,BottomLeftV},new double[2]{x,y},new double[3]{TopLeft,BottomLeft,BottomLeft},new double[3]{C2[idx],C2[idx],C2[idx-N1]});
         }
      }
      // cross left right case:
      //         +----+ ... C2[idx]
      //         |    |
      //     tlv + trv+ ... t2
      //         |\   |
      //         | \  |
      //         |  \ |
      //         |   \|
      //     blv + brv+ ... b2
      //         |    |
      //         |    |
      //         +----+ ... C2[idx-N1]
      //         .    .
      //         .    .
      // C1[idx-1]    C1[idx]
      if(dC1p[idx-1]==dC1m[idx]&&
            dC1p[idx-N1-1]==dC1m[idx-N1]&&
            dC2p[idx-N1-1]!=dC2m[idx-1]&&
            dC2p[idx-N1]!=dC2m[idx])
      {
         double leftb=dC2m[idx-1]<dC2p[idx-N1-1] ? C2[idx-1]-dC2m[idx-1] : C2[idx-N1-1]+dC2p[idx-N1-1]; // y of left intersection
         double rightb=dC2m[idx]<dC2p[idx-N1] ? C2[idx]-dC2m[idx] : C2[idx-N1]+dC2p[idx-N1]; // y of right intersection
         double lmv=fIsFixed[idx-1]?data[idx-1]:data[idx-N1-1]; // voltage of leftb
         double rmv=fIsFixed[idx]?data[idx]:data[idx-N1]; // voltage of rightb
         double LeftValueWithRightCorssPoint=leftb>rightb ?
            (leftb-rightb)/(leftb-C2[idx-N1-1])*data[idx-N1-1]+(rightb-C2[idx-N1-1])/(leftb-C2[idx-N1-1])*lmv : 
            (rightb-leftb)/(C2[idx-1]-leftb)*data[idx-1]+(C2[idx-1]-rightb)/(C2[idx-1]-leftb)*lmv;
         double RightValueWithLeftCorssPoint=leftb>rightb ?
            (rightb-leftb)/(C2[idx]-rightb)*data[idx]+(C2[idx]-leftb)/(C2[idx]-rightb)*rmv : 
            (leftb-C2[idx-N1])/(rightb-C2[idx-N1])*rmv+(rightb-leftb)/(rightb-C2[idx-N1])*data[idx-N1];
         double t2,b2,tlv,trv,blv,brv;

         if(leftb>rightb) {
            t2=leftb;
            tlv=lmv;
            trv=RightValueWithLeftCorssPoint;
            b2=rightb;
            blv=LeftValueWithRightCorssPoint;
            brv=rmv;
         } else {
            trv=rmv;
            t2=rightb;
            tlv=LeftValueWithRightCorssPoint;
            brv=RightValueWithLeftCorssPoint;
            b2=rightb;
            blv=lmv;
         }
         // find out whether the boundary goes from top-right to bottom-left or
         // from top-left to bottom-right and then do interpolation
         if(y>=t2) {
            return fourpoint(new double[4]{data[idx-1],data[idx],tlv,trv},
                  new double[2]{x,y},new double[4]{C1[idx-1],C1[idx],C1[idx-1],C1[idx]},
                  new double[4]{C2[idx],C2[idx],t2,t2});
         } else if(y<b2) {
            return fourpoint(new double[4]{blv,brv,data[idx-N1-1],data[idx-N1]},new double[2]{x,y},new double[4]{C1[idx-1],C1[idx],C1[idx-N1-1],C1[idx-N1]},new double[4]{b2,b2,C2[idx-N1-1],C2[idx-N1]});
         } else if((rightb-leftb)/(dC1m[idx])*(x-C1[idx-1])+(b2)>y) {
            return leftb>rightb ? threepoint(new double[3]{trv,blv,brv},new double[2]{x,y},new double[3]{C1[idx],C1[idx-N1],C1[idx-N1]},new double[3]{t2,b2,b2}) :
               threepoint(new double[3]{tlv,blv,brv},new double[2]{x,y},new double[3]{C1[idx],C1[idx-N1],C1[idx-N1]},new double[3]{t2,b2,b2});
         } else if((rightb-leftb)/(dC1m[idx])*(x-C1[idx-1])+(b2)<=y) {
            return leftb>rightb ? threepoint(new double[3]{tlv,blv,brv},new double[2]{x,y},new double[3]{C1[idx-1],C1[idx-1],C1[idx]},new double[3]{t2,b2,b2}) :
               threepoint(new double[3] {trv,blv,brv},new double[2]{x,y},new double[3]{C1[idx],C1[idx-1],C2[idx]},new double[3]{t2,b2,b2});
         }
      }
      return data[idx];
   } // 2D
   // 1D
   //     |<---dC1m[idx]--->|
   //     +---r1---+---r2---+
   // C1[idx-1]    x      C1[idx]
   size_t idx=GetIdxOfPointToTheRightOf(x,0,N1-1);
   double r2=(C1[idx]-x)/dC1m[idx];
   double r1=1-r2;
   double xval=data[idx]*r1+data[idx-1]*r2;
   if (gDebug>0) Info("GetData","data(x=%.4f)=%.2f, "
         "C1[%zu]=%.4f, C1[%zu]=%.4f, r1=%.2f, r2=%0.2f",
         x,xval,idx-1,C1[idx-1],idx,C1[idx],r1,r2);
   return xval;
}

GetE()

double GeFiCa::Grid::GetE ( double  c1, double  c2 = 0, double  c3 = 0  ) const

inline

Definition at line 88 of file Grid.h.

      { return GetData(Et,c1,c2,c3); }

GetE1()

double GeFiCa::Grid::GetE1 ( double  c1, double  c2 = 0, double  c3 = 0  ) const

inline

Definition at line 90 of file Grid.h.

      { return GetData(E1,c1,c2,c3); }

GetE2()

double GeFiCa::Grid::GetE2 ( double  c1, double  c2 = 0, double  c3 = 0  ) const

inline

Definition at line 92 of file Grid.h.

      { return GetData(E2,c1,c2,c3); }

GetE3()

double GeFiCa::Grid::GetE3 ( double  c1, double  c2 = 0, double  c3 = 0  ) const

inline

Definition at line 94 of file Grid.h.

      { return GetData(E3,c1,c2,c3); }

GetFieldLineFrom() [1/2]

FieldLine * Grid::GetFieldLineFrom ( double  c1, double  c2, bool  positive = true  )

virtual

Propogate a field line from (c1,c2,c3).

Examples:

pointContact/drawFields.cc.

Definition at line 629 of file Grid.cc.

{
   FieldLine *line=new FieldLine();

   int i=0;
   while (true) { // if (x,y) is in crystal
      line->C1.push_back(x);
      line->C2.push_back(y);
      if (x>=C1[GetN()-1]||x<=C1[0]||y>=C2[GetN()-1]||y<=C2[0]
            || fIsFixed[GetIdxOfPointToTheRightOf(x,y,0,N2)]) {//out of crystal
         if (i==0) // initial point is not in crystal
            Warning("GetFieldLineFrom", "Start point (%.1fcm,%.1fcm)"
                  " is not in crystal! Stop propagating.", x/cm, y/cm);
         break;
      }

      double ex = GetE1(x,y), ey = GetE2(x,y);
      double et = TMath::Sqrt(ex*ex+ey*ey); // total E
      if (et==0) {
         Warning("GetFieldLineFrom", "E@(x=%.1fmm,y=%.1fmm)=%.1fV/cm!",
               x/mm, y/mm, et/volt*cm);
         break;
      }
      double weight=5/(et/volt*mm); // propagate more in weaker field
      double dt=10*ns, mu=50000*cm2/volt/sec; // mu is mobility
      double dx=mu*ex*dt*weight, dy=mu*ey*dt*weight;
      line->dC1p.push_back(dx);
      line->dC2p.push_back(dy);
      if (gDebug>0)
         Printf("%04d x=%.3fmm, y=%.3fmm, Ex=%.2fV/cm, Ey=%.2fV/cm, "
               "weight=%.3f, dx=%.3fmm, dy=%.3fmm", i, x/mm, y/mm, ex/volt*cm,
               ey/volt*cm, weight, dx/mm, dy/mm);
      if (i>2000) {
         Info("GetFieldLineFrom", "Propagated more than 2000 steps. Stop");
         break;
      }
      if (positive) { x+=dx; y+=dy; } else { x-=dx; y-=dy; }
      i++;
   }

   return line;
}

GetFieldLineFrom() [2/2]

FieldLine * Grid::GetFieldLineFrom ( double  c1, double  c2, double  c3, bool  positive = true  )

virtual

Definition at line 673 of file Grid.cc.

{
   FieldLine *line=new FieldLine();

   int i=0;
   while (true) { // if (x,y,z) is in crystal
      line->C1.push_back(x);
      line->C2.push_back(y);
      line->C3.push_back(z);
      if (x>=C1[GetN()-1]||x<=C1[0]||y>=C2[GetN()-1]||y<=C2[0]
               || z>=C3[GetN()-1]||z<=C3[0]
               || fIsFixed[GetIdxOfPointToTheRightOf(x,y,z,N2)]) {//out of crystal
         if (i==0) // initial point is not in crystal
            Warning("GetFieldLineFrom", "Start point (%.1fcm,%.1fcm)"
                  " is not in crystal! Stop propagating.", x/cm, y/cm);
         break;
      }

   Printf("here");
      double ex = GetE1(x,y,z), ey = GetE2(x,y,z), ez = GetE3(x,y,z);
   Printf("here");
      double et = TMath::Sqrt(ex*ex+ey*ey+ez*ez); // total E
      if (et==0) {
         Warning("GetFieldLineFrom", "E@(x=%.1fmm,y=%.1fmm,z=%.1f)=%.1fV/cm!",
               x/mm, y/mm, z/mm, et/volt*cm);
         break;
      }
      double weight=5/(et/volt*mm); // propagate more in weaker field
      double dt=10*ns, mu=50000*cm2/volt/sec; // mu is mobility
      double dx=mu*ex*dt*weight, dy=mu*ey*dt*weight, dz=mu*ez*dt*weight;
      line->dC1p.push_back(dx);
      line->dC2p.push_back(dy);
      line->dC3p.push_back(dz);
      if (gDebug>0)
         Printf("%04d x=%.3fmm, y=%.3fmm, z=%.3fmm, Ex=%.2fV/cm, Ey=%.2fV/cm, "
                      "Ez=%.2fV/cm, weight=%.3f, dx=%.3fmm, dy=%.3fmm", i, x/mm, y/mm,
                      z/mm, ex/volt*cm, ey/volt*cm, ez/volt*cm, weight, dx/mm, dy/mm);
      if (i>2000) {
         Info("GetFieldLineFrom", "Propagated more than 2000 steps. Stop");
         break;
      }
      if (positive) { x+=dx; y+=dy; z+=dz; } else { x-=dx; y-=dy; z-=dz;}
      i++;
   }

   return line;
}

GetIdxOfMaxV()

size_t Grid::GetIdxOfMaxV ( )

protected

Get index of the grid point with max potential.

Definition at line 73 of file Grid.cc.

{
   double max=Vp[0]; size_t idx=0;
   for (size_t i=1; i<GetN(); i++) {
      if (Vp[i]>max) {
         idx=i;
         max=Vp[i];
      }
   }
   return idx;
}

GetIdxOfMinV()

size_t Grid::GetIdxOfMinV ( )

protected

Get index of the grid point with min potential.

Definition at line 86 of file Grid.cc.

{
   double min=Vp[0]; size_t idx=0;
   for (size_t i=1; i<GetN(); i++) {
      if (Vp[i]<min) {
         idx=i;
         min=Vp[i];
      }
   }
   return idx;
}

GetIdxOfPointToTheRightOf() [1/3]

size_t Grid::GetIdxOfPointToTheRightOf ( double  c1, size_t  begin, size_t  end  ) const

protected

Get index of point near.

Parameters

c1	in between
begin	&
end.

Definition at line 163 of file Grid.cc.

{
   //if (end==0) end=N1-1;
   if (begin>=end)return end;
   size_t mid=(begin+end)/2;
   if(C1[mid]>=c1)return GetIdxOfPointToTheRightOf(c1,begin,mid);
   else return GetIdxOfPointToTheRightOf(c1,mid+1,end);
}

GetIdxOfPointToTheRightOf() [2/3]

size_t Grid::GetIdxOfPointToTheRightOf ( double  c1, double  c2, size_t  begin, size_t  end  ) const

protected

Definition at line 173 of file Grid.cc.

{
   //if (end==0) end=N2-1;
   //search using binary search
   // if(begin>=end)cout<<"to x"<<begin<<" "<<end<<endl;;
   if(begin>=end)return GetIdxOfPointToTheRightOf(c1,end*N1,(end+1)*N1-1);
   size_t mid=((begin+end)/2);
   if(C2[mid*N1]>=c2) return GetIdxOfPointToTheRightOf(c1,c2,begin,mid);
   else return GetIdxOfPointToTheRightOf(c1,c2,mid+1,end);
}

GetIdxOfPointToTheRightOf() [3/3]

size_t Grid::GetIdxOfPointToTheRightOf ( double  c1, double  c2, double  c3, size_t  begin, size_t  end  ) const

protected

Definition at line 186 of file Grid.cc.

{
   //if (end==0) end=N3-1;
   //search using binary search
   if(begin>=end)return GetIdxOfPointToTheRightOf(c1,c2,begin,begin+N1*N2-1);
   size_t mid=((begin/(N1*N2)+end/(N1*N2))/2)*N1*N2;
   if(C3[mid]>=c3)return GetIdxOfPointToTheRightOf(c1,c2,c3,begin,mid);
   else return GetIdxOfPointToTheRightOf(c1,c2,c3,mid+1,end);
}

GetTree()

TTree * Grid::GetTree

(

bool

createNew = false

)

Create &/or return a TTree with field data.

Parameters

[in]

createNew

is a flag if false (default), the function returns the point of an existing tree, or create one if there is none. if true, the function always create a new tree and delete the old one if it exists.

Examples:

hemispherical/compare2analytic.cc, planar/checkInitialization.cc, planar/compare2analytic.cc, planar/showConvergingSteps.cc, pointContact/checkInitialization.cc, pointContact/drawFields.cc, segmented/drawSliceInPhi.cc, trueCoaxial/checkInitialization.cc, and trueCoaxial/compare2analytic.cc.

Definition at line 214 of file Grid.cc.

{
   if (fTree) { if (createNew) delete fTree; else return fTree; }

   // define tree
   bool b,d; double vp,et,e1,e2,e3,c1,c2,c3,p1,p2,p3,m1,m2,m3;
   fTree = new TTree("t","field data");
   fTree->SetDirectory(0);
   fTree->Branch("v",&vp,"v/D");
   fTree->Branch("e",&et,"e/D");
   // 1D data
   fTree->Branch("e1",&e1,"e1/D");
   fTree->Branch("c1",&c1,"c1/D");
   fTree->Branch("p1",&p1,"p1/D");
   fTree->Branch("m1",&m1,"m1/D");
   if (N2!=0) { // 2D data
      fTree->Branch("e2",&e2,"e2/D");
      fTree->Branch("c2",&c2,"c2/D");
      fTree->Branch("p2",&p2,"p2/D");
      fTree->Branch("m2",&m2,"m2/D");
   }
   if (N3!=0) { // 3D data
      fTree->Branch("e3",&e3,"e3/D");
      fTree->Branch("c3",&c3,"c3/D");
      fTree->Branch("p3",&p3,"p3/D");
      fTree->Branch("m3",&m3,"m3/D");
   }
   fTree->Branch("b",&b,"b/O"); // boundary flag
   fTree->Branch("d",&d,"d/O"); // depletion flag

   // fill tree
   Info("GetTree","%zu entries",GetN());
   for (size_t i=0; i<GetN(); i++) {
      e1=E1[i]; c1=C1[i]; p1=dC1p[i]; m1=dC1m[i]; // 1D data
      if (N2!=0) { e2=E2[i]; c2=C2[i]; p2=dC2p[i]; m2=dC2m[i]; } // 2D data
      if (N3!=0) { e3=E3[i]; c3=C3[i]; p3=dC3p[i]; m3=dC3m[i]; } // 3D data
      vp=Vp[i]; et=Et[i]; b=fIsFixed[i]; d=fIsDepleted[i]; // common data
      fTree->Fill();
   }

   fTree->GetListOfBranches()->ls();
   fTree->ResetBranchAddresses(); // disconnect from local variables
   return fTree;
}

GetV()

double GeFiCa::Grid::GetV ( double  c1, double  c2 = 0, double  c3 = 0  ) const

inline

Get potential at (c1,c2,c3) by interpolation.

Examples:

trueCoaxial/verifyCV.cc.

Definition at line 86 of file Grid.h.

      {return GetData(Vp,c1,c2,c3); }

IsDepleted()

bool Grid::IsDepleted

(

)

Check if every grid point is depleted.

Definition at line 99 of file Grid.cc.

{
   for(size_t i=0;i<GetN();i++) {
      // calculate one more time in case of adding two fields together,
      // one is depleted, the other is not
      OverRelaxAt(i);
      if (fIsDepleted[i]==false) return false;
   }
   return true;
}

operator*=()

Grid & Grid::operator*=

(

double

scale

)

Potentials at all points are multiplied by.

Parameters

scale.

Definition at line 66 of file Grid.cc.

{
   for (size_t i=0; i<GetN(); i++) Vp[i]=Vp[i]*scale;
   return *this;
}

operator+=()

Grid & Grid::operator+=

(

Grid &

other

)

Potentials of this grid are summed with those of.

Parameters

other

grid.

Definition at line 51 of file Grid.cc.

{
   if (GetN()!=other.GetN()) {
      Warning("+=", 
            "Numbers of points in two grids are different, return *this.");
      return *this; 
   }
   for (size_t i=0; i<GetN(); i++) {
      Vp[i]=Vp[i]+other.Vp[i];
      Src[i]=Src[i]+other.Src[i];
   }
   return *this;
}

OverRelaxAt()

virtual void GeFiCa::Grid::OverRelaxAt ( size_t  idx )

inlineprotectedvirtual

Over relax potential Vp[.

Parameters

idx].

Reimplemented in GeFiCa::R, GeFiCa::Rho, GeFiCa::X, GeFiCa::XYZ, GeFiCa::RhoPhi, GeFiCa::RhoZ, and GeFiCa::RTheta.

Definition at line 136 of file Grid.h.

{};

SetupWith()

void Grid::SetupWith ( Detector &  detector )

virtual

Fix potentials on boundaries based on.

Parameters

detector	geometry. It fills Points data based on
detector	geometry and N1, N2 and/or N3, and raises the flag fIsFixed for points on/outside electrodes. It has to be called before SuccessiveOverRelax().

Reimplemented in GeFiCa::XYZ, GeFiCa::R, GeFiCa::Rho, GeFiCa::RhoPhi, GeFiCa::RhoZ, GeFiCa::RTheta, and GeFiCa::X.

Definition at line 111 of file Grid.cc.

{
   if (GetN()>0) { // this function can only be called once
      Warning("SetupWith", "has been called. Do nothing.");
      return;
   }
}

SolveAnalytically()

void Grid::SolveAnalytically

(

)

Solve Poisson's Equation analytically.

It only accepts a constant impurity throughout the grid.

Definition at line 154 of file Grid.cc.

{
   if (Src[0]!=Src[N1-1]) {
      Error("SolveAnalytically", "can't handle changing impurity.");
      abort();
   }
}

SuccessiveOverRelax()

void Grid::SuccessiveOverRelax

(

)

Successively over-relax potentials on grid points.

Examples:

hemispherical/compare2analytic.cc, planar/compare2analytic.cc, planar/optimizeRelaxationFactor.cc, planar/showConvergingSteps.cc, pointContact/calculateFields.cc, pointContact/optimizeRelaxationFactor.cc, segmented/drawSliceInPhi.cc, trueCoaxial/compare2analytic.cc, and trueCoaxial/verifyCV.cc.

Definition at line 120 of file Grid.cc.

{
   if (dC1p.size()<1) {
      Error("SuccessiveOverRelax", "Grid is not ready. "
            "Please call SetupWith(Detector&) first.");
      abort();
   }
   Info("SuccessiveOverRelax","Start...");
   double error=1; Iterations=0;
   TStopwatch watch; watch.Start();
   while (Iterations<MaxIterations && error>Tolerance) {
      if (Iterations%100==0) Printf("%4zu steps, "
            "error: %.1e (tolerance: %.0e)", Iterations, error, Tolerance);
      double numerator=0, denominator=0;
      for (size_t i=0; i<GetN(); i++) {
         double old=Vp[i]; // save old value of Vp[i]
         OverRelaxAt(i); // update Vp[i]
         if(old>0) denominator+=old; else denominator-=old;
         double diff=Vp[i]-old;
         if(diff>0) numerator+=(diff); else numerator-=(diff);
      }
      if (denominator==0) {
         Error("SuccessiveOverRelax","Sum of Vs == 0!"); abort();
      }
      error = numerator/denominator;
      Iterations++;
   }
   CalculateE();
   Printf("%4zu steps, error: %.1e (tolerance: %.0e)",
         Iterations, error, Tolerance);
   Info("SuccessiveOverRelax", "CPU time: %.1f s", watch.CpuTime());
}

threepoint()

double Grid::threepoint ( double  dataset[3], double  tarlocationset[2], double  pointxset[3], double  pointyset[3]  ) const

protected

Calculate interpolation value between three point (triangle)

Definition at line 574 of file Grid.cc.

{
   double x=tarlocationset[0];
   double x1=pointxset[0];
   double x2=pointxset[1];
   double x3=pointxset[2];

   double y=tarlocationset[1];
   double y1=pointyset[0];
   double y2=pointyset[1];
   double y3=pointyset[2];
   //x=(1-u-v)*x1+u*x2+v*x3
   //y=(1-u-v)*y1+u*y2+v*y3
   double v=((y2-y1)*(x-x1)-(y-y1)*(x2-x1))/((x3-x1*(y2-y1)-(y3-y1)*(x2-x1)));
   double u=((y3-y1)*(x-x1)-(y-y1)*(x3-x1))/((x2-x1*(y3-y1)-(y2-y1)*(x3-x1)));
   //double u=(y-y1-v*(y3-y1))/(y2-y1);

   double result=dataset[0]*(1-u-v)+dataset[1]*u+dataset[2]*v;

   delete [] dataset;
   delete [] tarlocationset;
   delete [] pointxset;
   delete [] pointyset;

   if (TMath::Abs(result)<1e-10) return 0;
   return result;
}

twopoint()

double Grid::twopoint ( double  dataset[2], double  tarlocationset, double  pointxset[2]  ) const

protected

Calculate interpolation value between two point.

Definition at line 561 of file Grid.cc.

{
   double ab=(tarlocationset-pointxset[0])/(pointxset[1]-pointxset[0]);

   double result=dataset[0]*(1-ab) + dataset[1]*ab;
   delete [] dataset;
   delete [] pointxset;
   if (TMath::Abs(result)<1e-10) return 0;
   return result;
}

Member Data Documentation

fDetector

Detector* GeFiCa::Grid::fDetector

protected

! Pointer to associated detector object

Definition at line 132 of file Grid.h.

fIsDepleted

std::vector<bool> GeFiCa::Grid::fIsDepleted

protected

true if a grid point is depleted

Definition at line 130 of file Grid.h.

fIsFixed

std::vector<bool> GeFiCa::Grid::fIsFixed

protected

true if field values are fixed

Definition at line 129 of file Grid.h.

fTree

TTree* GeFiCa::Grid::fTree

protected

! ROOT tree to visualize fields

Definition at line 131 of file Grid.h.

Iterations

size_t GeFiCa::Grid::Iterations

number of iterations of SOR performed

Definition at line 60 of file Grid.h.

MaxIterations

size_t GeFiCa::Grid::MaxIterations

maximal iterations of SOR to be performed

Examples:

planar/optimizeRelaxationFactor.cc, planar/showConvergingSteps.cc, and pointContact/optimizeRelaxationFactor.cc.

Definition at line 57 of file Grid.h.

N1

size_t GeFiCa::Grid::N1

number of points along the 1st coordinate

Definition at line 53 of file Grid.h.

N2

size_t GeFiCa::Grid::N2

number of points along the 2nd coordinate

Definition at line 54 of file Grid.h.

N3

size_t GeFiCa::Grid::N3

number of points along the 3rd coordinate

Definition at line 55 of file Grid.h.

RelaxationFactor

double GeFiCa::Grid::RelaxationFactor

within (0,2), used to speed up convergence

Examples:

planar/optimizeRelaxationFactor.cc, pointContact/calculateFields.cc, pointContact/optimizeRelaxationFactor.cc, and trueCoaxial/verifyCV.cc.

Definition at line 58 of file Grid.h.

Src

std::vector<double> GeFiCa::Grid::Src

-(net impurity concentration)x|Qe|/epsilon

Definition at line 56 of file Grid.h.

Tolerance

double GeFiCa::Grid::Tolerance

SOR stops when error<Tolerance.

Definition at line 59 of file Grid.h.

---

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

• Grid.h
• Grid.cc