root/trunk/EBaporate/shorts.c

/***************************************
  $Header$

  This file has lots of little functions ("shorts") to do simple tasks which
  one might want to modify, such as beam patterns, thermal and evaporative
  heat loss functions and beam penetration depth.  The best ``documentation''
  for these little functions is probably the source code itself, especially
  since they were written at a time when I thought, ``The more code we can get
  on the screen at once, the better!''.
***************************************/

#include "ebsurf.h"

/*************** Time-dependent generation functions ***************/

/* The standard "pattern": one beam strike at t=3tres */
double gtnorm (double t, struct param *p)
{ return exp(-(2*t/p->tres-3)*(2*t/p->tres-3)); } /* Normal version */

/* Lissidue pattern, different frequency & waveform oscillations in x and y */
/* Sine wave for lissidue pattern */
double sino(double t, double freq)
{ return sin(2*M_PI*t*freq); }
/* Triangle wave for lissidue pattern */
double triang(double t, double freq)
{ return _ABS((t*freq-floor(t*freq))*4-2)-1; }
/* Sawtooth wave for lissidue pattern */
double sawt(double t, double freq)
{ return (t*freq-floor(t*freq))*2-1; }
/* Then the pattern generator itself */
double gtliss(double t, struct param *p)
{
  double x,y;
  x=p->plen/2*p->xpat(t,p->xfrq)-p->x;
  y=p->pwid/2*p->ypat(t,p->yfrq)-p->y;
  return exp(-4*x*x/p->spx/p->spx-4*y*y/p->spy/p->spy);
}

/* Adam Powell's innovative disk pattern for a circular hearth/mold */
double gtdisk(double t, struct param *p)
{ double x,y;
  x=.25*p->plen*(cos(2.*M_PI*t*p->xfrq)+cos(2.*M_PI*t*p->yfrq))-p->x;
  y=.25*p->pwid*(sin(2.*M_PI*t*p->xfrq)+sin(2.*M_PI*t*p->yfrq))-p->y;
  return exp(-x*x/p->spx/p->spx-y*y/p->spy/p->spy); }

/************ Thermal and evaporation and beam functions ***********/

/* Radiation heat loss */
double radloss(double T, struct param *p)
{ return p->eps * SIGMA * (T*T*T*T - p->Tenv*p->Tenv*p->Tenv*p->Tenv); }

/* Evaporation flux, (moles/cm^2/second) */
double vloss(double T, double E, double A, double C, double D)
{ return E*exp(-A/T+C*log(T)+D*T); }

/* Aluminum k'' value */
double vloss2(double T, double E, double A, double C, double D)
{ return 8.2924243e-5 * exp (log(10.)*(-16450./T+12.36) - 1.523*log(T)); }

/* dVapFlux/dTsurf (moles/cm^2/second/K) */
double vlossder(double T, double E, double A, double C, double D)
{ return E * (A/T/T+C/T+D) * exp(-A/T+C*log(T)+D*T); }

/* Total radiative + evaporative heat losses (erg/cm^2/second) */
double loss(double T, struct param *p)
{
  return radloss (T,p) +
    p->Q0*exp(p->S*T) * vloss (T,p->E,p->A,p->C,p->D);
}

/* Derivative of total heat loss wrt. surf temperature (erg/cm^2/second/K) */
double lossder (double T, struct param *p)
{ return 4*p->eps*SIGMA*T*T*T +
    p->Q0*exp(p->S*T) * vlossder(T,p->E,p->A,p->C,p->D) +
    p->Q0*p->S*exp(p->S*T) * vloss(T,p->E,p->A,p->C,p->D); }

/* Calculate the beam penetration depth in g/cm^2 (divide by density to get the
   actual depth) as a function of voltage (kV).  This uses a line segment fit
   to the log-log curve given by Schiller Electron Beam Technology, p. 39:
   10  keV -> .00026 g/cm^2 -> .000063 cm in titanium
   30  keV -> .0020  g/cm^2 -> .00049 cm
   100 keV -> .015   g/cm^2 -> .0036 cm
   300 keV -> .082   g/cm^2 -> .020 cm
   1   MeV -> .40    g/cm^2 -> .10 cm */
#define logfit(x,x1,x2,y1,y2) \
  exp(log(y1)+(log(y2)-log(y1))*(log(x)-log(x1))/(log(x2)-log(x1)))
double depvolt(volts) double volts;
{ void errer();
  if(volts<10) errer("No data available for energy below 10 kV.");
  if(volts<30) return logfit(volts,10,30,.00026,.002);
  if(volts<100) return logfit(volts,30,100,.002,.015);
  if(volts<300) return logfit(volts,100,300,.015,.082);
  if(volts<=1000) return logfit(volts,300,1000,.082,.4);
  errer("No data available for energy above 1 MV."); }
#undef logfit