Heed::SimpleTablePhotoAbsCS Class Reference

#include <PhotoAbsCS.h>

Inheritance diagram for Heed::SimpleTablePhotoAbsCS:

Public Member Functions
	SimpleTablePhotoAbsCS ()
	SimpleTablePhotoAbsCS (const String &fname, int fZ, double fthreshold, const String &ffile_name)
	SimpleTablePhotoAbsCS (const String &fname, int fZ, double fthreshold, const DynLinArr< double > &fener, const DynLinArr< double > &fcs)
	SimpleTablePhotoAbsCS (const String &fname, int fZ, double fthreshold, int l, double E0, double yw, double ya, double P, double sigma)
	SimpleTablePhotoAbsCS (const SimpleTablePhotoAbsCS &total, const SimpleTablePhotoAbsCS &part, double emax_repl)
virtual	~SimpleTablePhotoAbsCS ()
void	remove_leading_zeros (void)
void	remove_leading_tiny (double level)
virtual double	get_CS (double energy) const
virtual double	get_integral_CS (double energy1, double energy2) const
const DynLinArr< double > &	get_arr_ener () const
const DynLinArr< double > &	get_arr_CS () const
virtual void	scale (double fact)
virtual void	print (std::ostream &file, int l) const
	macro_copy_total (SimpleTablePhotoAbsCS)

Detailed Description

Definition at line 177 of file PhotoAbsCS.h.

Constructor & Destructor Documentation

SimpleTablePhotoAbsCS() [1/5]

Heed::SimpleTablePhotoAbsCS::SimpleTablePhotoAbsCS

(

)

SimpleTablePhotoAbsCS() [2/5]

Heed::SimpleTablePhotoAbsCS::SimpleTablePhotoAbsCS	(	const String &	fname,
		int	fZ,
		double	fthreshold,
		const String &	ffile_name
	)

Definition at line 413 of file PhotoAbsCS.cpp.

    : PhotoAbsCS(fname, fZ, fthreshold), file_name(ffile_name) {
  mfunnamep("SimpleTablePhotoAbsCS::SimpleTablePhotoAbsCS(...)");
#ifdef USE_STLSTRING
  std::ifstream file(file_name.c_str());
#else
  std::ifstream file(file_name);
#endif
  if (!file) {
    funnw.ehdr(mcerr);
    mcerr << "cannot open file " << file_name << std::endl;
    spexit(mcerr);
  }
  long q = 0;  // number of read values
  ener = DynLinArr<double>(10, 0.0);
  cs = DynLinArr<double>(10, 0.0);
  do {
    file >> ener[q];
    //Iprintn(mcout, file.good());
    //Iprintn(mcout, file.eof());
    //Iprintn(mcout, file.fail());
    //Iprintn(mcout, file.bad());
    //file.clear();  // idiotic thing necessary for the new compiler
    if (!file.good()) break;
    check_econd11(ener[q], < 0.0, mcerr);
    if (q > 0) {
      check_econd12(ener[q], <, ener[q - 1], mcerr);
    }
    ener[q] *= 1.0e-6;  // convertion to MeV
    file >> cs[q];
    if (!file.good()) break;
    check_econd11(cs[q], < 0.0, mcerr);
    q++;
    if (q == ener.get_qel()) {  // increasing the size of arrays
      long q1 = q * 2;
      ener.put_qel(q1);
      cs.put_qel(q1);
    }
  } while (1);
  if (q != ener.get_qel()) {  // reducing the size if necessary
    ener.put_qel(q);
    cs.put_qel(q);
  }
 
}

SimpleTablePhotoAbsCS() [3/5]

Heed::SimpleTablePhotoAbsCS::SimpleTablePhotoAbsCS	(	const String &	fname,
		int	fZ,
		double	fthreshold,
		const DynLinArr< double > &	fener,
		const DynLinArr< double > &	fcs
	)

Definition at line 460 of file PhotoAbsCS.cpp.

    : PhotoAbsCS(fname, fZ, fthreshold),
      file_name("none"),
      ener(fener),
      cs(fcs) {
  mfunname("SimpleTablePhotoAbsCS::SimpleTablePhotoAbsCS(...)");
  check_econd12(ener.get_qel(), !=, cs.get_qel(), mcerr);
}

SimpleTablePhotoAbsCS() [4/5]

Heed::SimpleTablePhotoAbsCS::SimpleTablePhotoAbsCS	(	const String &	fname,
		int	fZ,
		double	fthreshold,
		int	l,
		double	E0,
		double	yw,
		double	ya,
		double	P,
		double	sigma
	)

Definition at line 472 of file PhotoAbsCS.cpp.

    : PhotoAbsCS(fname, fZ, fthreshold) {
  mfunname("SimpleTablePhotoAbsCS::SimpleTablePhotoAbsCS");
  long q = 1000;
  ener = make_log_mesh_ec(2.0e-6, 2.0e-1, q);
  cs.put_qel(q, 0.0);
  long n;
  for (n = 0; n < q; n++) {
    double energy = ener[n];
    if (energy < threshold)
      cs[n] = 0.0;
    else {
      double Q = 5.5 + l - 0.5 * P;
      double y = energy / E0;
      double Fpasc = ((y - 1) * (y - 1) + yw * yw) * pow(y, (-Q)) *
                     pow((1.0 + sqrt(y / ya)), (-P));
      Fpasc = Fpasc * sigma;
      cs[n] = Fpasc;
      //Iprint3n(mcout, energy, E0, threshold);
      //Iprint4n(mcout, Q, y, sigma, Fpasc);
    }
  }
  remove_leading_zeros();
}

SimpleTablePhotoAbsCS() [5/5]

Heed::SimpleTablePhotoAbsCS::SimpleTablePhotoAbsCS	(	const SimpleTablePhotoAbsCS &	total,
		const SimpleTablePhotoAbsCS &	part,
		double	emax_repl
	)

Definition at line 500 of file PhotoAbsCS.cpp.

                                                               {
  mfunname("SimpleTablePhotoAbsCS::SimpleTablePhotoAbsCS (const "
           "SimpleTablePhotoAbsCS& total,...)");
 
  *this = total;  // to assure that all is preserved
 
  long qe_i = total.ener.get_qel();
 
  const DynLinArr<double>& ener_r = part.get_arr_ener();
  const DynLinArr<double>& cs_r = part.get_arr_CS();
  long qe_r = ener_r.get_qel();
  BlkArr<double> new_ener;  // arrays to grow
  BlkArr<double> new_cs;
  long qe = 0;
  long ne;
  for (ne = 0; ne < qe_r; ne++)  // first write replacements
      {
    if (ener_r[ne] >= total.get_threshold() && ener_r[ne] <= emax_repl) {
      qe++;
      new_ener.put_qel(qe);
      new_cs.put_qel(qe);
      new_ener[qe - 1] = ener_r[ne];
      new_cs[qe - 1] = cs_r[ne];
    }
  }
  for (ne = 0; ne < qe_i; ne++) {
    if (ener[ne] >= total.get_threshold() && ener[ne] > emax_repl) {
      qe++;
      new_ener.put_qel(qe);
      new_cs.put_qel(qe);
      new_ener[qe - 1] = total.ener[ne];
      new_cs[qe - 1] = total.cs[ne];
    }
  }
  ener.put_qel(qe);
  cs.put_qel(qe);
  for (ne = 0; ne < qe; ne++) {
    ener[ne] = new_ener[ne];
    cs[ne] = new_cs[ne];
    //Iprint3n(mcout, ne, ener[ne], cs[ne]);
 
  }
}

~SimpleTablePhotoAbsCS()

virtual Heed::SimpleTablePhotoAbsCS::~SimpleTablePhotoAbsCS ( )

inlinevirtual

Definition at line 194 of file PhotoAbsCS.h.

{}

Member Function Documentation

get_arr_CS()

const DynLinArr< double > & Heed::SimpleTablePhotoAbsCS::get_arr_CS ( ) const

inline

Definition at line 211 of file PhotoAbsCS.h.

{ return cs; }

Referenced by Heed::ExAtomPhotoAbsCS::ExAtomPhotoAbsCS(), and SimpleTablePhotoAbsCS().

get_arr_ener()

const DynLinArr< double > & Heed::SimpleTablePhotoAbsCS::get_arr_ener ( ) const

inline

Definition at line 210 of file PhotoAbsCS.h.

{ return ener; }

Referenced by Heed::ExAtomPhotoAbsCS::ExAtomPhotoAbsCS(), and SimpleTablePhotoAbsCS().

get_CS()

double Heed::SimpleTablePhotoAbsCS::get_CS ( double  energy ) const

virtual

Definition at line 585 of file PhotoAbsCS.cpp.

                                                        {
  mfunname("double SimpleTablePhotoAbsCS::get_CS(double energy) const");
  //mcout<<"SimpleTablePhotoAbsCS::get_CS is started\n";
  //Iprintn(mcout, energy);
  long q = ener.get_qel();
  if (q == 0) return 0.0;
  check_econd11(q, == 1, mcerr);
  //Iprint3n(mcout, threshold,  ener[0], energy);
  if (energy < threshold)
    return 0.0;
  else {
    if (energy <= ener[q - 1]) {
      //mcout<<"Create mesh\n";
      PointCoorMesh<double, const DynLinArr<double> > pcmd(q, &ener);
      double s;
      s = t_value_generic_point_ar<
          double, DynLinArr<double>,
          PointCoorMesh<double, const DynLinArr<double> > >(
          pcmd, cs, &my_val_fun, energy, 1, threshold, 0, DBL_MAX);
      return s;
    } else {
      if (energy == DBL_MAX)
        return 0.0;
      else
        return cs[q - 1] * pow(energy, -2.75) / pow(ener[q - 1], -2.75);
    }
 
    /*
    long i1, i2;
    long q = ener.get_qel();
    if(energy < ener[0])
    {
      i1 = 0;
      i2 = 1;
      return cs[i1] + (energy - ener[i1])*(cs[i2] - cs[i1])/
        (ener[i2] - ener[i1]);
    }
    else
    {
      if(energy < ener[q-1])
      {
        // now find interval
        i1 = 0;
        i2 = q-1;
        while( i2 - i1 != 1)
        {
          long i3 = (i1 + i2)/2;
          if(energy < ener[i3])
            i2 = i3;
          else
            i1 = i3;
        }
        //mcout<<"i12="<<i1<<' '<<i2
        //     <<" ener="<< ener[i1] <<' '<< ener[i2] <<std::endl;
        // now make interpolation
        // linear is not always good
        //return cs[i1] + (energy -
        //                 ener[i1])*(cs[i2] - cs[i1])/(ener[i2] - ener[i1]);
        //if(cs[i2] >= cs[i1] || ener[i2] < 1.2*ener[i1] ||
        //   cs[i1] == 0 || cs[i2] == 0 )
        if( sign_nonlinear_interpolation(ener[i1], cs[i1],
                                         ener[i2], cs[i2], threshold) == 0 )
        {  // linear case
          //mcout<<"linear\n";
          //Iprintn(mcout, cs[i1] + (energy - ener[i1])*(cs[i2] -
    cs[i1])/(ener[i2] - ener[i1]) );
          return cs[i1] + (energy -
                           ener[i1])*(cs[i2] - cs[i1])/(ener[i2] - ener[i1]);
        }
        else
        {
          //mcout<<"power\n";
          //power
          double pw = log(cs[i1]/cs[i2]) / log(ener[i1]/ener[i2]);
          //Iprintn(mcout, pw);
          return cs[i1] * pow( energy , pw ) / pow( ener[i1] , pw );
        }
      }
      else
      {
        return cs[q-1] * pow( energy , -2.75 ) / pow( ener[q-1] , -2.75 );
      }
    }
    */
  }
}

get_integral_CS()

double Heed::SimpleTablePhotoAbsCS::get_integral_CS ( double  energy1, double  energy2  ) const

virtual

Definition at line 672 of file PhotoAbsCS.cpp.

                                                                    {
  mfunname("double SimpleTablePhotoAbsCS::get_integral_CS(...)");
 
  long q = ener.get_qel();
  if (q == 0) return 0.0;
  check_econd11(q, == 1, mcerr);
  //Iprint2n(mcout, energy2, threshold);
  if (energy2 < threshold) return 0.0;
  if (energy1 < threshold) energy1 = threshold;
  double s = 0.0;
  double energy21 = ener[q - 1];
  if (energy1 < energy21) {
    if (energy21 > energy2) energy21 = energy2;
    check_econd12(energy1, >, energy21, mcerr);
    s = glin_integ_ar(ener, cs, ener.get_qel(), energy1, energy21, threshold);
  }
  //print(mcout, 3);
  //mcout << "energy1="<<energy1
  //      << " energy21="<<energy21
  //      << " ener[q-1]="<<ener[q-1]
  //      << " threshold="<<threshold
  //      << " s="<<s<<'\n';
  check_econd11(s, < 0.0, mcout);
  if (energy2 > ener[q - 1]) {
    // add tail
    if (energy2 == DBL_MAX) {
      if (energy1 < ener[q - 1]) energy1 = ener[q - 1];
      double c =
          cs[q - 1] / (1.75 * pow(ener[q - 1], -2.75)) * pow(energy1, -1.75);
      //check_econd11(c , < 0.0, mcout);
      s += c;
    } else {
      if (energy1 < ener[q - 1]) energy1 = ener[q - 1];
      double c = cs[q - 1] / (1.75 * pow(ener[q - 1], -2.75)) *
                 (pow(energy1, -1.75) - pow(energy2, -1.75));
      //check_econd11(c , < 0.0, mcout);
      s += c;
    }
  }
  return s;
}

macro_copy_total()

Heed::SimpleTablePhotoAbsCS::macro_copy_total

(

SimpleTablePhotoAbsCS

)

print()

void Heed::SimpleTablePhotoAbsCS::print ( std::ostream &  file, int  l  ) const

virtual

Definition at line 723 of file PhotoAbsCS.cpp.

                                                               {
  if (l > 0) {
    Ifile << "SimpleTablePhotoAbsCS: name=" << name << " Z = " << Z
          << std::endl;
    Ifile << " threshold = " << threshold << " file_name=" << file_name
          << std::endl;
    if (l > 1) {
      indn.n += 2;
      for (long n = 0; n < ener.get_qel(); ++n) {
        Ifile << "n=" << n << " ener=" << ener[n] << " cs=" << cs[n]
              << std::endl;
      }
      indn.n -= 2;
    }
  }
}

remove_leading_tiny()

void Heed::SimpleTablePhotoAbsCS::remove_leading_tiny

(

double

level

)

Definition at line 565 of file PhotoAbsCS.cpp.

                                                            {
  long q = ener.get_qel();
  long ne;
  long nez;
  for (ne = 0; ne < q; ne++) {
    if (cs[ne] > level) break;
  }
  if (ne > 0) {
    long qn = q - ne;
    DynLinArr<double> enern(qn);
    DynLinArr<double> csn(qn);
    for (nez = ne; nez < q; nez++) {
      enern[nez - ne] = ener[nez];
      csn[nez - ne] = cs[nez];
    }
    ener = enern;
    cs = csn;
  }
}

Referenced by Heed::ExAtomPhotoAbsCS::ExAtomPhotoAbsCS().

remove_leading_zeros()

void Heed::SimpleTablePhotoAbsCS::remove_leading_zeros

(

void

)

Definition at line 546 of file PhotoAbsCS.cpp.

                                                     {
  long q = ener.get_qel();
  long ne;
  long nez;
  for (ne = 0; ne < q; ne++) {
    if (cs[ne] > 0.0) break;
  }
  if (ne > 0) {
    long qn = q - ne;
    DynLinArr<double> enern(qn);
    DynLinArr<double> csn(qn);
    for (nez = ne; nez < q; nez++) {
      enern[nez - ne] = ener[nez];
      csn[nez - ne] = cs[nez];
    }
    ener = enern;
    cs = csn;
  }
}

Referenced by Heed::ExAtomPhotoAbsCS::ExAtomPhotoAbsCS(), and SimpleTablePhotoAbsCS().

scale()

void Heed::SimpleTablePhotoAbsCS::scale ( double  fact )

virtual

Definition at line 715 of file PhotoAbsCS.cpp.

                                             {
  mfunnamep("void SimpleTablePhotoAbsCS::scale(double fact)");
  long q = ener.get_qel();
  for (long n = 0; n < q; ++n) {
    cs[n] *= fact;
  }
}

---

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

• PhotoAbsCS.h
• PhotoAbsCS.cpp