package ConductingMaterial
@ISA = qw()

sub Thickness
return shift->{Thicnkess};

sub SetThickness
sub SetThickness     { my($this,$d)=
return $this->{Thicnkess} = $d;

sub SetName
sub SetName          { my($this,$n)=
return $this->{Name} = $n;

sub Name
sub Name             { my($this)=
return $this->{Name};

sub Temperature
return shift->{Temperature};

sub SetTemperature
sub SetTemperature   { my($this,$T)=
return $this->{Temperature} = $T;

sub SetEnergyStructure
my ($this, $EC, $EV, $EF, $me, $mh, $ND, $ED, $NA, $EA) = @_;

sub SetProperties
my ($this, $Eps, $mue, $taue, $mup, $taup) = @_;
my ($this, $Name, $value) = @_;
return $p->[$ModelName]->{$VarName} = $value;
return $p->[$i]->{$VarName} = $value;
return undef;
return $this->{$Name} = $value;
my ($this, $Name) = @_;
return \$p->[$ModelName]->{$VarName};
return \$p->[$i]->{$VarName};
return undef;
return \$this->{$Name};

sub new
my ($module, $material, $name, $app, %args) = @_;
return $this;

sub DESTROY
my $this = shift;

sub Initialize
my ($this) = @_;

sub MakeMaterial
my ($this, $material, $name) = @_;

sub PrepareForCalculation
my ($this) = @_;

sub CalSigma
my ($this, $EF, $T) = @_;
return $sigma * 1.0e4;

sub CalTauAveraged
my ($this, $EF, $T, $n, $ConsiderBarrierProbability) = @_;
return $tauaveraged / $Ne;

sub CalDriftMobility
my ($this, $EF, $T) = @_;
return $e * $tauaveraged / $Effme / $me * 1.0e4;

sub CalHallMobility
my ($this, $EF, $T) = @_;
return $e * $R / $Effme / $me * 1.0e4;

sub CalSeebeck
my ($this, $EF, $T, $r, $iChargePolarity) = @_;
return -$S if($iChargePolarity <= 0);
return $S;

sub CalSeebeckWithNonDegenerateApproximation
my ($this, $EF, $T, $r, $iChargePolarity) = @_;
return -($kB/$e) * ($r+2.0 - ($EF-$this->{Ec})*$e/$kB/$T) if($iChargePolarity <= 0);
return  ($kB/$e) * ($r+2.0 - ($this->{Ev}-$EF)*$e/$kB/$T);

sub CalSeebeckWithDegenerateApproximation
my ($this, $EF, $T, $r, $iChargePolarity) = @_;
return -($kB/$e) * ($r+1.0) * ($pi*$pi/3.0) / (($EF-$this->{Ec})*$e/$kB/$T) if($iChargePolarity <= 0);
return  ($kB/$e) * ($r+1.0) * ($pi*$pi/3.0) / (($this->{Ev}-$EF)*$e/$kB/$T);

sub tau
my ($this, $T, $E, @taur) = @_;
return 0.0 if($E < 0.0);
return 0.0 if($E == 0.0 and $r != 0.5);
return 0.0 if($tau == 0.0);
return 1.0 / $tinv;

sub BarrierProbability
my ($this, $E, $Ec, $E0) = @_;
return 1.0 if($E >= $Ec);
return 0.0;
return 0.5 * (1.0 - $r);
return 0.5 * (1.0 + $ret);

sub CalDOSc
my ($this, $Dc0, $Ec, $Nt0, $Eth, $Eu, $nE, $Estart, $Estep) = @_;
return (\@Energyc, \@Dc);

sub CalDOSv
my ($this, $Dv0, $Ev, $Nt0, $Eth, $Eu, $nE, $Estart, $Estep) = @_;
return (\@Energyv, \@Dv);

sub CalEF
my ($this, $T, $nMaxIter, $xEPS, $SEPS, $IsPrint) = @_;
return ($EF, -1.0);
					$this->{Ev}-1.0, $this->{Ec}+5.0, sub { $this->CalS($T, 
				sub { $this->CalNewtonS2($T, 
				sub { Optimize::BuildDifferentialMatrixes(
return ($EF, $S);

sub EiFromEffectiveMass
my ($this, $T) = @_;
return $EF;

sub CalEFWithApproximation
my ($this, $T) = @_;
return $this->{Ec} + $kB*$T * log($this->{ND}/$this->{Nc}) * $JToeV;
return $this->{Ev} - $kB*$T * log($this->{NA}/$this->{Nv}) * $JToeV;
return $this->EiFromEffectiveMass($T);

sub CalS
my ($this, $T, $EF, $IsPrint) = @_;
return $S;

sub CalNewtonS2
my ($this, $T, $pVars, $IsPrint) = @_;
return $S2;

sub CalNe
my ($this, $EF, $T) = @_;
return Algorism::SinglePointIntegrateBySimpson($pEnergyc, \@Dfc);

sub CalNh
my ($this, $EF, $T) = @_;
return Algorism::SinglePointIntegrateBySimpson($pEnergyv, \@Dfv);
return -Algorism::SinglePointIntegrateBySimpson($pEnergyv, \@Dfv);

sub CalNDp
my ($this, $EF, $T) = @_;
return $this->{ND} * $FE;

sub CalNAm
my ($this, $EF, $T) = @_;
return $this->{NA} * $this->FEe($this->{EA}, $EF, $T);

sub dFEedE
my ($this, $E, $EF, $T) = @_;
return 0.0 if($T == 0.0);
return -1.0 / $T / $KToeV * $ex / ($ex1*$ex1);

sub FEe
my ($this, $E, $EF, $T) = @_;
return 0.0 if($E > $EF);
return 0.5 if($E == $EF);
return 1.0;
return 1.0 / ( 1.0 + exp(($E-$EF) / $T / $KToeV) );

sub FEh
my ($this, $E, $EF, $T) = @_;
return 0.0 if($E < $EF);
return 0.5 if($E == $EF);
return 1.0;
return 1.0 / ( 1.0 + exp(($EF-$E) / $T / $KToeV) );