RFdeviceField Class Reference

Inheritance diagram for RFdeviceField:

List of all members.

---

Detailed Description

RFdeviceField represents one placement of an rfdevice.

frequency=0.0 is accepted and yields an rfdevice with a constant Ez = maxGradient (useful to verify units are correct).

Public Member Functions
	RFdeviceField (G4String &_name, BLCoordinateTransform &_global2local, BLCMDrfdevice *_rfdevice, G4VPhysicalVolume *_timingPV)
	constructor. _zmin/max are global coordinates.
G4String	getName ()
	getName() returns the name of this placement.
void	addFieldValue (const G4double point[4], G4double field[6]) const
	addFieldValue() adds the field for this rfdevice into field[]. point[] is in global coordinates.
void	UserSteppingAction (const G4Step *step)
	doStep() handles a step of the timing particle.
void	show1step (AutoTimingState state, const char *pre, G4double wrkval, const char *suf)
	show1step() prints handy messages about autoTiming
void	reset ()
	reset() resets various internal used by autoTime to initial settings
Private Attributes
G4String	name
BLCMDrfdevice *	rfdevice
G4VPhysicalVolume *	timingPV
BLCoordinateTransform	global2local
G4RotationMatrix *	rotation
G4Track	saveTrack
G4int	timeCount
G4bool	validSaveTrack
BLFieldMap *	fieldMap
AutoTimingMethod	automethod
AutoTimingState	stateOfPlacement
G4double	maxGradient
G4double	timeOffset
G4int	redo
char	pbname [256]
int	timeCount000
G4bool	revisited_timingZero
double	timingZero
double	timingPhase
double	timingZeroStep
double	timingPhaseStep
double	timingGrad
double	timingGradStep
AutoTimingChange	previous
int	cycle
double	ampl
double	drift
AutoTimingSnapshot	entrance
AutoTimingSnapshot	exit
AutoTimingSnapshot	base
AutoTimingSnapshot	estimate
Friends
class	BLCMDrfdevice

---

Constructor & Destructor Documentation

RFdeviceField::RFdeviceField	(	G4String &	_name,
		BLCoordinateTransform &	_global2local,
		BLCMDrfdevice *	_rfdevice,
		G4VPhysicalVolume *	_timingPV
	)

constructor. _zmin/max are global coordinates.

References ampl, ATWORKING_UNKNOWN, cycle, drift, BLCMDrfdevice::fieldMap, fieldMap, BLCoordinateTransform::getGlobal(), getName(), BLCoordinateTransform::getRotation(), global2local, BLCMDrfdevice::innerLength, BLCMDrfdevice::innerRadius, BLCoordinateTransform::isRotated(), maxGradient, name, pbname, redo, revisited_timingZero, rfdevice, rotation, BLElementField::setGlobalPoint(), stateOfPlacement, timeCount, timeCount000, timeOffset, timingGrad, timingGradStep, timingPhase, timingPhaseStep, timingPV, timingZero, timingZeroStep, BLCommand::undefined(), validSaveTrack, and BLCMDrfdevice::wallThick.

                                                      :
                        BLElementField(), BLManager::SteppingAction()
{
        name = _name;
        stateOfPlacement= ATWORKING_UNKNOWN;
        maxGradient= BLCommand::undefined();
        timeOffset= BLCommand::undefined();
        redo= 0;

        rfdevice = _rfdevice;
        timingPV = _timingPV;
        global2local = _global2local;
        rotation = 0;

        //use rfdevicefield #s if available, then rfdevice #s, then safe values

        timeCount = 0;
        validSaveTrack = false;
        fieldMap = rfdevice->fieldMap;

        if(global2local.isRotated()) {
                rotation = new G4RotationMatrix(global2local.getRotation());
                rotation->invert();
        }

        // set global bounding box
        G4double local[4], global[4];
        local[3] = 0.0;
        G4double dz = rfdevice->innerLength/2.0 + rfdevice->wallThick;
        for(int i=0; i<2; ++i) {
                local[0] = (i==0 ? -1.0 : 1.0) * rfdevice->innerRadius;
                for(int j=0; j<2; ++j) {
                        local[1] = (j==0 ? -1.0 : 1.0) * rfdevice->innerRadius;
                        for(int k=0; k<2; ++k) {
                                local[2] = (k==0 ? -1.0 : 1.0) * dz;
                                global2local.getGlobal(local,global);
                                setGlobalPoint(global);
                        }
                }
        }

        sprintf(pbname,"%s",getName().c_str());
        int timeCount000= 0;         
        G4bool revisited_timingZero= false;   
        double timingZero= 0;           
        double timingPhase= 0;           
        double timingZeroStep= 0;         
        double timingPhaseStep= 0;   
        double timingGrad= 0;       
        double timingGradStep=0;      
        int cycle= 0;              
        double ampl= 0;               
        double drift= 0;                 
}

---

Member Function Documentation

G4String RFdeviceField::getName

(

)

[inline]

getName() returns the name of this placement.

References name.

Referenced by RFdeviceField(), and UserSteppingAction().

{ return name; }

void RFdeviceField::addFieldValue	(	const G4double	point[4],
		G4double	field[6]
	)			const [virtual]

addFieldValue() adds the field for this rfdevice into field[]. point[] is in global coordinates.

Implements BLElementField.

References B, E, BLCMDrfdevice::E2Bfactor, fieldMap, BLCMDrfdevice::frequency, BLFieldMap::getFieldValueNoTimeNoScale(), BLCoordinateTransform::getLocal(), global2local, BLCMDrfdevice::innerLength, BLCMDrfdevice::innerRadius, BLCommand::isUndefined(), BLCMDrfdevice::maxGradient, maxGradient, BLCMDrfdevice::omega, BLCMDrfdevice::rFactor, rfdevice, rotation, BLCMDrfdevice::skinDepth, BLCMDrfdevice::timeOffset, timeOffset, TINY_NONZERO_GRADIENT, and BLCMDrfdevice::wallThick.

{
        G4double local[4];
        global2local.getLocal(local,point);

        //use locked rfdevicefield values if available, 
        //then working rfdevice value, then a safe value

        G4double tOff = !BLCommand::isUndefined(timeOffset)? timeOffset : 
          !BLCommand::isUndefined(rfdevice->timeOffset) ? rfdevice->timeOffset : 0;

        G4double Vo = !BLCommand::isUndefined(maxGradient)? maxGradient :
          !BLCommand::isUndefined(rfdevice->maxGradient) ? rfdevice->maxGradient : TINY_NONZERO_GRADIENT;

        if(fieldMap) {
                G4double myField[6];

                //KBB-8mar11: this getFieldValue applies time & gradient!
                //
                //              fieldMap->getFieldValue(local,myField,rfdevice->maxGradient,
                //                              rfdevice->maxGradient);

                fieldMap->getFieldValueNoTimeNoScale(local,myField);  //KBB-8mar11: w/o time, scale applied

                // frequency == 0.0 means a d.c. electric field
                G4double timeE=1.0, timeB=0.0;
                if(rfdevice->frequency != 0) {
                  double tArg = rfdevice->omega * (point[3] - tOff);
                  timeE = cos(tArg);
                  timeB = -sin(tArg);  //KBB 6/17/2011
                }

                timeE *= Vo/(megavolt/meter);
                timeB *= Vo/(megavolt/meter);

                if(rotation) {
                        G4ThreeVector B(myField[0],myField[1],myField[2]);
                        G4ThreeVector E(myField[3],myField[4],myField[5]);
                        B = *rotation * B;
                        E = *rotation * E;
                        field[0] += B[0] * timeB;
                        field[1] += B[1] * timeB;
                        field[2] += B[2] * timeB;
                        field[3] += E[0] * timeE;
                        field[4] += E[1] * timeE;
                        field[5] += E[2] * timeE;
                } else {
                        field[0] += myField[0] * timeB;
                        field[1] += myField[1] * timeB;
                        field[2] += myField[2] * timeB;
                        field[3] += myField[3] * timeE;
                        field[4] += myField[4] * timeE;
                        field[5] += myField[5] * timeE;
                }
                return;
        }

        G4double x = local[0];
        G4double y = local[1];
        G4double z = local[2];
        G4double r = sqrt(x*x + y*y);
        G4double dz = rfdevice->innerLength/2.0 + rfdevice->wallThick;
        if(z < -dz || z > dz || r > rfdevice->innerRadius) return;

        // frequency == 0.0 means a d.c. electric field
        if(rfdevice->frequency == 0.0) {
                // zmin and zmax include the walls, so re-test z position
                if(z >= -rfdevice->innerLength/2.0 && 
                   z <=  rfdevice->innerLength/2.0) {
                        if(rotation) {
                                G4ThreeVector E(0.0, 0.0, Vo);
                                E = *rotation * E;
                                field[3] += E[0];
                                field[4] += E[1];
                                field[5] += E[2];
                        } else {
                                field[5] += Vo;
                        }
                }
                return;
        }

        // compute normal RF rfdevice field
        double arg = rfdevice->rFactor*r;
        if(fabs(arg) < 1.0e-20) arg = 0.0;
        double j0 = gsl_sf_bessel_J0(arg);
        double j1 = gsl_sf_bessel_J1(arg);
        double tArg = rfdevice->omega * (point[3] - tOff);
        double ez = Vo * j0 * cos(tArg);
        double bphi = -Vo * rfdevice->E2Bfactor * j1 * sin(tArg);
        // handle skin depth if in wall or window
        double f = 1.0;
        if(z > rfdevice->innerLength/2.0)
                f=exp(-(z-rfdevice->innerLength/2.0)/rfdevice->skinDepth);
        else if(z < -rfdevice->innerLength/2.0)
                f=exp(-(-z-rfdevice->innerLength/2.0)/rfdevice->skinDepth);
        //@ double phi = atan2(point[1],point[0]);
        //@ TJR 3/29/2011 - this surel should be local, not point
        double phi = atan2(local[1],local[0]);
        if(rotation) {
                G4ThreeVector B(-bphi*sin(phi)*f, bphi*cos(phi)*f, 0.0);
                G4ThreeVector E(0.0, 0.0, ez*f);
                B = *rotation * B;
                E = *rotation * E;
                field[0] += B[0];
                field[1] += B[1];
                field[2] += B[2];
                field[3] += E[0];
                field[4] += E[1];
                field[5] += E[2];
        } else {
                field[0] += -bphi * sin(phi) * f;
                field[1] += bphi * cos(phi) * f;
                field[5] += ez * f;
        }
}

void RFdeviceField::UserSteppingAction

(

const G4Step *

step

)

[virtual]

doStep() handles a step of the timing particle.

Implements BLManager::SteppingAction.

References ampl, BLCMDrfdevice::argChanged(), ATFIX_DE, ATFIX_DT, ATFIX_GRADIENT, ATFIX_OFFSET, ATFIX_OFFSETINCR, ATFIX_P, ATFIX_PHASE, ATFIX_XDEFL, ATFIX_YDEFL, ATWORKING_BASE, ATWORKING_BYPASS, ATWORKING_DONE, ATWORKING_ESTIMATE, ATWORKING_FINAL, ATWORKING_FINETUNE, ATWORKING_INFLUX, ATWORKING_OFFSET, ATWORKING_RESET, ATWORKING_UNKNOWN, AUTOADJUST_GRADIENT, AUTOADJUST_OUTPUT, AUTOADJUST_PHASE, AUTOADJUST_UNKNOWN, AUTOADJUST_UNNEEDED, automethod2text(), automethod2timingphase(), autotiming2method(), AUTOTIMING_ATZ, AUTOTIMING_MAXDXP, AUTOTIMING_MAXDYP, AUTOTIMING_MAXENERGY, AUTOTIMING_MAXTIME, AUTOTIMING_MINDXP, AUTOTIMING_MINDYP, AUTOTIMING_MINENERGY, AUTOTIMING_MINTIME, AUTOTIMING_NODXP, AUTOTIMING_NODYP, AUTOTIMING_NOENERGY, AUTOTIMING_NOMTIME, BLCMDrfdevice::autoTimingFailureLimit, BLCMDrfdevice::autoTimingFixDE, BLCMDrfdevice::autoTimingFixDT, BLCMDrfdevice::autoTimingFixP, BLCMDrfdevice::autoTimingFixXdeflection, BLCMDrfdevice::autoTimingFixYdeflection, autoTimingIn2Out(), BLCMDrfdevice::autoTimingMethod, base, cycle, AutoTimingChange::dE, drift, AutoTimingChange::dT, entrance, ESSENTIALLY_UNCHANGED, estimate, AutoTimingSnapshot::estTransit, exit, fieldMap, BLCMDrfdevice::frequency, BLFieldMap::getFieldValue(), BLGlobalField::GetFieldValue(), getName(), BLGlobalField::getObject(), BLManager::getObject(), BLManager::getSteppingManager(), BLCommand::isUndefined(), ITERATION_LIMIT, lastFound_maxGradient, BLCMDrfdevice::LtimingVolume, AutoTimingSnapshot::m, BLCMDrfdevice::maxGradient, maxGradient, BLCMDrfdevice::omega, pbname, BLCMDrfdevice::phaseAcc, AutoTimingChange::Pout, previous, AutoTimingSnapshot::Ptot, AutoTimingSnapshot::q, redo, reset(), revisited_timingZero, rfdevice, rotation, saveTrack, show1step(), BLCMDrfdevice::state, state2desc(), stateOfPlacement, step2snapshot(), AutoTimingSnapshot::t, timeCount, timeCount000, BLCMDrfdevice::timeIncrement, BLCMDrfdevice::timeOffset, timeOffset, timingGrad, timingGradStep, timingPhase, timingPhaseStep, timingPV, BLCMDrfdevice::timingTolerance, timingZero, timingZeroStep, TrackOfInterest, BLCommand::undefined(), validSaveTrack, BLCMDrfdevice::verbose, BLCMDrfdevice::what2adjust, BLCMDrfdevice::whatFixed, whatFixedOk(), AutoTimingSnapshot::within, AutoTimingSnapshot::x, AutoTimingChange::Xdefl, AutoTimingSnapshot::y, AutoTimingChange::Ydefl, and AutoTimingSnapshot::z.

{
  /*
    The traditional pillbox autophasing only worked for a 
    single cell cavity; here it's
    been generallized to any RF structure (via an specified RF map)
    and supports determining the timeOffset in a number of ways.

    In general, it won't matter much which method you specify to
    determine timeOffset - the AtZ is sets the arrival time for
    a local Z location (usually the center z=0), but isn't appropriate
    for all cases.  Usually people adjust the phase for maximum 
    energy gain and call that "on crest", 90degRF in the G4beamline
    notation.
    
    KBB March-April 2011
  */
  static int stepcall=0;

  TrackOfInterest= false;

  if(rfdevice->verbose>4)
    {
      printf("\nRFdeviceField::UserSteppingAction %s call#%d timeCount=%d %d=%s->rfdevice->state=%d=%s ", 
             getName().c_str(), stepcall, timeCount, stateOfPlacement, state2desc(stateOfPlacement),
             rfdevice->state, state2desc(rfdevice->state));

      printf("whatFixed=%d what2adjust=%d ",rfdevice->whatFixed,rfdevice->what2adjust);

      printf("frequency=%gGHz maxGradient=%gMV/m timeOffset=%gns\n",
             rfdevice->frequency*ns, maxGradient/(megavolt/meter), timeOffset/ns);

      fflush(stdout);
    }

  /* 
     need to find out position w.r.t. rfdevice in case "tune" is in use 
     to update TrackOfInterest - otherwise could wait and do this later 
  */

  G4Track *track = step->GetTrack();
  G4StepPoint *prePoint = step->GetPreStepPoint();
  if(!prePoint) return;
  G4VPhysicalVolume *prePV = prePoint->GetPhysicalVolume();
  G4StepPoint *postPoint = step->GetPostStepPoint();
  if(!postPoint) return;
  G4VPhysicalVolume *postPV = postPoint->GetPhysicalVolume();
  G4SteppingManager *steppingMgr = BLManager::getObject()->getSteppingManager();

  enum WhereROI { ROI_OUTSIDE, ROI_ENTERING, ROI_INSIDE, ROI_EXITING };
  WhereROI whereROI;  
  
  if(prePV == timingPV && postPV == timingPV)
    whereROI= ROI_INSIDE;
  else if(prePV != timingPV && postPV == timingPV)
    whereROI= ROI_ENTERING;
  else if(prePV == timingPV && postPV != timingPV)
    whereROI= ROI_EXITING;
  else
    whereROI= ROI_OUTSIDE;

  G4bool Interesting=  prePV==timingPV || postPV==timingPV;

  // DC field specified
  if(rfdevice->frequency<=0)  
    {
      stateOfPlacement= rfdevice->state= ATWORKING_DONE;
      timeOffset= rfdevice->timeOffset= 0;
      maxGradient= rfdevice->maxGradient;
      TrackOfInterest= Interesting;
      return;
    }
 
  // zero field specified
  if(rfdevice->whatFixed & ATFIX_GRADIENT && rfdevice->maxGradient==0)  
    {
      stateOfPlacement= rfdevice->state= ATWORKING_DONE;
      maxGradient= rfdevice->maxGradient;
      timeOffset= rfdevice->timeOffset= 0;
      TrackOfInterest= Interesting;
      return;
    }

  // everything needed specified in advance
  if(rfdevice->what2adjust==AUTOADJUST_UNNEEDED)
    {
      stateOfPlacement= rfdevice->state= ATWORKING_DONE;
      maxGradient= rfdevice->maxGradient;
      timeOffset= rfdevice->timeOffset;
      if(rfdevice->whatFixed & ATFIX_OFFSETINCR)  timeOffset+= rfdevice->timeIncrement;
      TrackOfInterest= Interesting;
      return;
    }

  ++stepcall;
  
  //"tune" 2nd pass requires a re-autoTiming from beginning
  //(can improve efficiency later by comparing to previous entrance snapshot-KBB)
  if(whereROI==ROI_ENTERING)  //restart when reentering timingVolume - w/o "tune" only once
    {
      rfdevice->state= ATWORKING_RESET;
    }

  if(stateOfPlacement==ATWORKING_UNKNOWN || 
      rfdevice->state==ATWORKING_UNKNOWN || rfdevice->state==ATWORKING_RESET)  //clean start
    {
      if(stateOfPlacement==ATWORKING_DONE) ++redo;
      rfdevice->state= ATWORKING_RESET;  //force to initial state
      rfdevice->argChanged();
      rfdevice->state= ATWORKING_UNKNOWN;
      this->reset();
   }

  //no more work to do - rfdevice may be in use elsewhere
  if(stateOfPlacement==ATWORKING_DONE && !BLCommand::isUndefined(maxGradient) && !BLCommand::isUndefined(timeOffset)) 
    return;

  stateOfPlacement= ATWORKING_INFLUX;

  if(!timingPV)  G4Exception("rfdevice","Missing timing volume",FatalException,"");
  
  AutoTimingMethod method= autotiming2method(rfdevice->autoTimingMethod);
  
  if(prePV == postPV) return;     // neither entering nor leaving, do nothing

  if(rfdevice->verbose>2)
    {
      printf("\nRFdeviceField::UserSteppingAction %s call#%d redo#%d:timeCount=%d ", 
             getName().c_str(), stepcall, redo, timeCount);

      printf("stateOfPlacement=%d=%s->rfdevice->state=%d=%s ", 
             stateOfPlacement,state2desc(stateOfPlacement),
             rfdevice->state,state2desc(rfdevice->state));

      printf("what2adjust=%d ",rfdevice->what2adjust);

      printf("frequency=%gGHz pf.maxGradient=%g p.maxGradient=%gMV/m pf.timeOffset=%g p.timeOffset=%gns\n",
             rfdevice->frequency*ns, maxGradient/(megavolt/meter), rfdevice->maxGradient/(megavolt/meter), 
             timeOffset/ns, rfdevice->timeOffset/ns);

      fflush(stdout);
    }

  //KBB-mar11 complete rethink of adjusting RF 
 
  const G4bool RevisitTimingAfterGradientAdjust= true;  //once correct gradient found, 
                                                        //refind timing zero using that gradient

  const G4bool TurnTransportationThresholdDownward= false;  //Geant4 thresholds of ~100-250MeV usually OK
                                                            //but in some rare case where particle is
                                                            //supposed to be trapped may be too high -
                                                            //does no harm to turn it on, except may prevent
                                                            //inhibit detection of trapped particles
  G4bool firstVisit=false,AnotherPass=false;
  G4int verbose= rfdevice->verbose;
  static G4bool negativeParticle=false;                
    
  AutoTimingChange chng;                  //change over timing volume

  double RFperiod= 1./rfdevice->frequency; //1 RFperiod in native time units
  double degRF= RFperiod/360.;            //1 degRF in native time units

  double dt=0,phi=0;

  if(rfdevice->state==ATWORKING_UNKNOWN)  //initialize all static info
    {
      if(verbose)
        {
          printf("RFdeviceField::UserSteppingAction - %s - initialize ",pbname);
          fflush(stdout);
        
          printf("whatFixed=0x%X what2adjust=0x%X\n",rfdevice->whatFixed,rfdevice->what2adjust);
        }

      if(rfdevice->what2adjust==AUTOADJUST_UNKNOWN)  //abort
        G4Exception("RFdeviceField::UserSteppingAction","what2adjust==AUTOADJUST_UNKNOWN",FatalException,"");

      if(!whatFixedOk(pbname, rfdevice->whatFixed))
        G4Exception("RFdeviceField::UserSteppingAction","whatFixed not OK",FatalException,"");  //abort

      stepcall= 0;
      cycle= 1;
      timingZero=0; 
      timingPhase= BLCommand::undefined();
      timingZeroStep=0; 
      chng.dE= chng.Pout= chng.dT= chng.Xdefl= chng.Ydefl= 0;
      previous= chng;
      entrance.within= exit.within= false;
            
      firstVisit= true;

      if(rfdevice->state & ATFIX_OFFSET)
        {
          timingZero= rfdevice->timeOffset;
          rfdevice->state= ATWORKING_BYPASS;     //timeOffset known already; satisfy other conditions
        }
      else
        {
          rfdevice->state= ATWORKING_OFFSET;     //start working on determining timeOffset
          timingZero= rfdevice->timeOffset= 0;   //initial value
        }
    }
  else
    {
      firstVisit= false;
    }
  
  if(verbose)  // show progress for now
    {
      const G4ThreeVector& tmp_xyz= postPoint->GetPosition();
      G4double xyzt[4];
      xyzt[0]= tmp_xyz.getX();
      xyzt[1]= tmp_xyz.getY();
      xyzt[2]= tmp_xyz.getZ();
      xyzt[3]= postPoint->GetGlobalTime();
      
      const G4ThreeVector& tmp_mom= postPoint->GetMomentum();
      G4double Pxyz[3];
      Pxyz[0]= tmp_mom.getX();
      Pxyz[1]= tmp_mom.getY();
      Pxyz[2]= tmp_mom.getZ();
      
      G4double herefield[6];
      BLGlobalField::getObject()->GetFieldValue(xyzt,herefield);
      if(this->fieldMap)
        this->fieldMap->getFieldValue(xyzt,herefield);
      
      if(firstVisit)  //only print once 
        {
          if(verbose>1)
            {
              printf("kbb:ROI:status(name) #x y z Px Py Pz t - - - - - Bx By Bz Ex Ey Ez count KE step\n");
              
              printf("kbb:method=%d=%s\n", method, automethod2text(method));

              fflush(stdout);
            }
        }
      
      if(verbose>1)
        {
          printf("kbb:ROI:%s(%s) ", 
                 whereROI==ROI_INSIDE ? "inside" : 
                 whereROI==ROI_ENTERING ? "entering" :
                 whereROI==ROI_EXITING ? "EXITing" : "outside", pbname);
          
          printf("%g %g %g ",xyzt[0]/mm,xyzt[1]/mm,xyzt[2]/mm);
          
          printf("%g %g %g ",Pxyz[0]/MeV,Pxyz[1]/MeV,Pxyz[2]/MeV);
          
          printf("%g 0 0 0 0 0 ",xyzt[3]/ns);
          
          printf("%g %g %g ",herefield[0]/tesla,herefield[1]/tesla,herefield[2]/tesla);
          
          printf("%g %g %g ",herefield[3]/(megavolt/meter),
                 herefield[4]/(megavolt/meter),herefield[5]/(megavolt/meter));
          
          int g= stepcall;
          printf("timeCount=%d %g stepcall=%d ",timeCount,track->GetKineticEnergy()/MeV,g);
          
          printf("%d=%s\n",rfdevice->state, state2desc(rfdevice->state));
          
          fflush(stdout);
        }
    }
  
  // Region-Of-Interest //

  switch(whereROI) 
    {
    case ROI_INSIDE:               //entirely inside - keep going
    case ROI_OUTSIDE:              //entirely outside - keep going
      return;

    case ROI_ENTERING:             //entering into timing volume - only once/rfdevice
      {
        G4RotationMatrix *rot= rotation;

        entrance= step2snapshot(step, rfdevice->timeOffset, rfdevice->LtimingVolume, rot, true);
        
        drift= entrance.estTransit;  //drift time
        
        timingPhase= automethod2timingphase(method, entrance.q);
        
        negativeParticle= entrance.q<0; 

        if(verbose>1 && firstVisit) 
          {
            printf("kbb------ %s ------- %s ",
                   pbname, automethod2text(method));
            
            printf("Gradient=%.3f MV/m",rfdevice->maxGradient/(megavolt/meter));
            if(rfdevice->whatFixed&ATFIX_PHASE)
              printf(", phaseAcc=%.1f degRF ",rfdevice->phaseAcc/deg);

            printf(", timingPhase=%gdeg ",timingPhase/deg);

            printf("\n");
            fflush(stdout);
          } 

        //In some rare future case a nearly trapped particle may be part of the plan...
        //but not in any of the current concepts.  This is primarially just FYI:
        if(firstVisit && TurnTransportationThresholdDownward)
          {
            // sometimes the track gets stuck after the rfdevice -
            // it is unclear why - so tweak Process->Transportation settings

            G4ProcessManager *procMgr = saveTrack.GetDefinition()->GetProcessManager();

            G4ProcessVector *procList= procMgr->GetProcessList();
            
            for(int i=0; i<procList->size(); ++i) //look through whole list
              {
                if(verbose>1)
                  printf("kbb::process#%d %s\n", i, (*procList)[i]->GetProcessName().data());
                
                if((*procList)[i]->GetProcessName()=="Transportation")
                  {
                    G4Transportation *trans= (G4Transportation *) (*procList)[i];
                    
                    G4double init_trans_ThresholdWarningEnergy= trans->GetThresholdWarningEnergy();
                    G4double init_trans_ThresholdImportantEnergy= trans->GetThresholdImportantEnergy();
                    G4int init_trans_ThresholdTrials= trans->GetThresholdTrials();
                    
                    // avoid Tune being killed for getting stuck or looping near boundry
                    
                    trans->SetThresholdWarningEnergy(0.1*keV);  //typically 100MeV
                    trans->SetThresholdImportantEnergy(0.250*keV);       //typically 250MeV
                    trans->SetThresholdTrials(3050);            //typically 10
                    
                    if(verbose>1)
                      {
                        printf("kbb::trans->ThresholdWarningEnergy=%g=>%gMeV ", 
                               init_trans_ThresholdWarningEnergy/MeV,trans->GetThresholdWarningEnergy()/MeV);
                        
                        printf("ThresholdImportantEnergy=%g=>%gMeV ", 
                               init_trans_ThresholdImportantEnergy/MeV,trans->GetThresholdImportantEnergy()/MeV);
                        
                        printf("GetThresholdTrials=%d=>%d\n", 
                               init_trans_ThresholdTrials,trans->GetThresholdTrials());
                      }
                  }
                
                fflush(stdout);
              }
          }
            
        // save track for setting up timeOffset, etc.
        // will return to this track later

        saveTrack.CopyTrackInfo(*step->GetTrack());
        saveTrack.SetUserInformation(0);
        validSaveTrack = true;
        
        if(verbose>1)  // show progress for now
          {
            printf("kbb-enter:%d timeOffset=%g\n",timeCount,rfdevice->timeOffset/ns);
            fflush(stdout);
          } 
        
        if(firstVisit)
          {
            if(rfdevice->state==ATWORKING_OFFSET)          // first visit to this rfdevice
              {
                timingZero= rfdevice->timeOffset= 0;            // convenient settings
                timingZeroStep= 0*degRF;              // 0 degRF
              }
            else
              {
                timingZero= rfdevice->timeOffset;
              }
            
            if(rfdevice->what2adjust==AUTOADJUST_GRADIENT)  //estimate a reasonable starting value
              {
                double DISCARD=ESSENTIALLY_UNCHANGED;
                double q= entrance.q;
                double c= c_light;
                double L= rfdevice->LtimingVolume;
                double to= entrance.estTransit;
                double m= entrance.m;
                double Po= entrance.Ptot;
                double Eo= sqrt(Po*Po+m*m);
                double w= !BLCommand::isUndefined(rfdevice->phaseAcc)? rfdevice->phaseAcc : pi/2;
                double dt= rfdevice->whatFixed & ATFIX_DT ? rfdevice->autoTimingFixDT - to : 0;
                double dE= rfdevice->whatFixed & ATFIX_DE ? rfdevice->autoTimingFixDE : 0;
                double Pf= rfdevice->whatFixed & ATFIX_P ? rfdevice->autoTimingFixP : Po;
                double xdf= rfdevice->whatFixed & ATFIX_XDEFL ? rfdevice->autoTimingFixXdeflection : 0;
                double ydf= rfdevice->whatFixed & ATFIX_YDEFL ? rfdevice->autoTimingFixYdeflection : 0;
                
                //avoid divide-by-zero issues; let it work on crest
                double sin_w= fabs(sin(w)) > DISCARD ? sin(w) : 1;
                double aw= fabs(ampl*sin(w)) > DISCARD ? ampl*sin(w) : 1;
                
                if(rfdevice->whatFixed & ATFIX_P)  //estimate dE from fixP & Po
                  {
                    dE= sqrt(Pf*Pf+m*m) - Eo;
                  }
                
                //simplest possible model as a starting point
                
                if(rfdevice->whatFixed & (ATFIX_P | ATFIX_DE)) 
                  {
                    double wavelength= 2*pi*c_light/rfdevice->omega;

                    if(2*L<wavelength)
                      timingGrad= dE*pi/(q*wavelength*sin(pi*L/wavelength)*sin_w);  //single cell?
                    else
                      timingGrad= dE*pi/(q*2*L*sin_w);      //multicell?
                  }
                else if(rfdevice->whatFixed & ATFIX_DT)        //total transit time
                  { 
                    timingGrad= (m/sqrt(1-1/pow(c*dt/L+Eo/Po,2.))-Eo)/(q*L*sin_w);
                  }
                else if(rfdevice->whatFixed & ATFIX_XDEFL)     //deflection angle in radians
                  {
                    timingGrad= (xdf/radian)*(Po/MeV)/q/(to/ns) * 
                      0.3*megavolt/meter/sin_w;
                  }
                else if(rfdevice->whatFixed & ATFIX_YDEFL)
                  {
                    timingGrad= (ydf/radian)*(Po/MeV)/q/(to/ns) *
                      0.3*megavolt/meter/sin_w;
                  }
                else if(lastFound_maxGradient!=0)
                  {
                    timingGrad= lastFound_maxGradient;
                  }
                else
                  {
                    timingGrad= 1*megavolt/meter;     //no idea - ought to never happen
                  }
                
                rfdevice->maxGradient= timingGrad;
                
                if(verbose>1)
                  {
                    printf("kbb:ROI:(%s) guess at working Gradient=%.3f MV/m\n", 
                           pbname, rfdevice->maxGradient/(megavolt/meter));
                  }
              }
          }         

        return;                    //keep going on toward exit
      }
        
    case ROI_EXITING:
      break;                       //stop & process
    }
  
  // ROI_EXITING

  ++timeCount;

  exit= step2snapshot(step, rfdevice->timeOffset, rfdevice->LtimingVolume, rotation, true);
  chng= autoTimingIn2Out(entrance, exit);
  
  if(timeCount > ITERATION_LIMIT)
    G4Exception("rfdevice","Iteration Limit",FatalException,"");  //abort
  
  AnotherPass= true;
  
  switch(rfdevice->state)
    {
    case ATWORKING_OFFSET:
      {
        //determine basic timeOffset; RF ~ sin(w*(t-timeOffset))
        
        if(exit.within!=true)
          G4Exception("rfdevice","Exit w/o Enter",FatalException,"");  //abort
        
        /*********************************************************************************
               KBB: Assume that dE, dT, Xdeflection, Ydeflection approximately follow a sine-like curve - 
               from 2 points 90 degrees apart in phase, estimate time offset for a maximum
               f(wto)= K sin(w(t-to)+phi) = K sin(phi)
               f(wto+RFperiod/4)= K sin(w(t-to)+phi+TT/2)=  K cos(w(t-to)+phi)= K cos(phi)
               f(wto)/f(wto+RFperiod/4) = tan(phi) 
               f(t=to) => sin(w(t-to)+phi)= 0 -> w(t-to)-phi=0 -> t-to=phi/w
        *********************************************************************************/
        
        if(timeCount<=1 || timeCount000+1==timeCount)  /*KBB always get 1st of 2 points to start */
          {
            //timeOffset and timingZero were 0 
            
            show1step(rfdevice->state,"(1of3)timingzero=",timingZero/ns,"ns");
            
            rfdevice->timeOffset= timingZero + pi/2/rfdevice->omega;  // was 0 -> now shift +90degRF
            
            if(verbose>1)
              printf("kbb.1: was timeZero=timeOffset=0 => 90degRF\n");

            rfdevice->state= ATWORKING_OFFSET; 
          }
        else if(timeCount==2 || timeCount000+2==timeCount) /*KBB always from 2nd point, estimate overall phase */
          {
            show1step(rfdevice->state,"(2of3)timingzero=",timingZero/ns,"ns");
            
            //timeOffset was 90degRF from first
            
            if(method==AUTOTIMING_ATZ)      //KBB: based on TJR's original method of arrival time
              {                               //at a local Z (timingVolume exit); usually middle of cell
                                              // time of arrival   
                double t = track->GetGlobalTime();                  //time now (usually at the center)
                                
                double dt= t - timingZero - timingPhase/rfdevice->omega; 
                
                while(dt>+RFperiod/2)  dt-= RFperiod;

                while(dt<-RFperiod/2)  dt+= RFperiod;

                timingZero+= dt;
                
                phi= atan2(previous.dE, chng.dE);      //kinetic energy change (for subsequent adjustments)

                if(verbose>1)
                  printf("kbb.2: dt=%gns timingZero->%gns\n",dt/ns,timingZero/ns);
              }
            else if(method==AUTOTIMING_MAXENERGY || method==AUTOTIMING_NOENERGY || method==AUTOTIMING_MINENERGY)
              {
                phi= atan2(previous.dE, chng.dE);      //kinetic energy change  
                ampl= sqrt(previous.dE*previous.dE + chng.dE*chng.dE);
              }
            else if(method==AUTOTIMING_MINTIME || method==AUTOTIMING_NOMTIME || method==AUTOTIMING_MAXTIME)
              {
                phi= atan2(previous.dT-drift, chng.dT-drift);        //(transit.time-drift) change
                ampl= sqrt((previous.dT-drift)*(previous.dT-drift) + (chng.dT-drift)*(chng.dT-drift));
              }
            else if(method==AUTOTIMING_MAXDXP || method==AUTOTIMING_NODXP || method==AUTOTIMING_MINDXP)
              {
                phi= atan2(previous.Xdefl, chng.Xdefl);        //X deflection
                ampl= sqrt(previous.Xdefl*previous.Xdefl + chng.Xdefl*chng.Xdefl);
              }
            else if(method==AUTOTIMING_MAXDYP || method==AUTOTIMING_NODYP || method==AUTOTIMING_MINDYP)
              {
                phi= atan2(previous.Ydefl, chng.Ydefl);        //Y deflection
                ampl= sqrt(previous.Ydefl*previous.Ydefl + chng.Ydefl*chng.Ydefl);
              }
            else
              {
                phi= BLCommand::undefined();  //unknown method
                ampl= BLCommand::undefined();
              }

            if(rfdevice->whatFixed & (ATFIX_DE | ATFIX_P) || method==AUTOTIMING_ATZ)
              {
                ampl= sqrt(previous.dE*previous.dE + chng.dE*chng.dE);
              }
            else if(rfdevice->whatFixed & ATFIX_DT )
              {
                ampl= sqrt((previous.dT-drift)*(previous.dT-drift) + (chng.dT-drift)*(chng.dT-drift));
              }
            else if(rfdevice->whatFixed & ATFIX_XDEFL)
              {
                ampl= sqrt(previous.Xdefl*previous.Xdefl + chng.Xdefl*chng.Xdefl);
              }
            else if(rfdevice->whatFixed & ATFIX_YDEFL)
              {
                ampl= sqrt(previous.Ydefl*previous.Ydefl + chng.Ydefl*chng.Ydefl);
              }
            
            if(verbose>1)
              {
                printf("kbb.2: pass1-2 amplitude=");
                !BLCommand::isUndefined(ampl) ? printf("%g",ampl) : printf("undefined()");
                printf(" delta-phi-zero=");
                !BLCommand::isUndefined(phi) ? printf("%gdegRF",phi/deg) : printf("undefined()");
                printf(" timingZero=%gns rfdevice->timeOffset=%gns",timingZero/ns,rfdevice->timeOffset/ns);
                printf("\n");
              }

            if(method!=AUTOTIMING_ATZ && !BLCommand::isUndefined(phi))  //phi of the sine-like signal, not necc. overall phase
              {
                //redefine timingZero to new value
                timingZero= phi/rfdevice->omega;   //zero crossing time w.r.t. previous 1st pass timeOffset=0

                if(negativeParticle)
                  timingZero+= pi/rfdevice->omega;  //negative particle shifted by 180deg

                rfdevice->timeOffset= timingZero - timingPhase/rfdevice->omega;

                if(verbose>1)
                  {
                    printf("kbb.2a: pass1-2 amplitude=");
                    !BLCommand::isUndefined(ampl) ? printf("%g",ampl) : printf("undefined()");
                    printf(" delta-phi-zero=");
                    !BLCommand::isUndefined(phi) ? printf("%gdegRF",phi/deg) : printf("undefined()");
                    printf(" timingZero=%gns rfdevice->timeOffset=%gns",timingZero/ns,rfdevice->timeOffset/ns);
                    printf("\n");
                  }
              }

            rfdevice->state= ATWORKING_OFFSET; 
          }
        else    //all other passes...
          {
            if(method==AUTOTIMING_ATZ)      //KBB: based on TJR's original method of arrival time
              {                               //at a local Z (timingVolume exit); usually middle of cell
                                              // time of arrival   
                double t = track->GetGlobalTime();                  //time now (usually at the center)
                
                show1step(rfdevice->state,"timingzero=",timingZero/ns,"ns");
                
                double dt= t - (timingZero - timingPhase/rfdevice->omega); 
                
                while(dt>+RFperiod/2)  dt-= RFperiod;

                while(dt<-RFperiod/2)  dt+= RFperiod;

                timingZero+= dt;
                
                AnotherPass= fabs(dt) > rfdevice->timingTolerance;              
                
                if(verbose>1)
                  printf("kbb.%d: dt=%gns timingZero->%gns Another=%s\n",
                         timeCount,dt/ns,timingZero/ns,AnotherPass?"Y":"N");

              }
            else if(timeCount==3 || timeCount000+3==timeCount) //ought to have timingZero to be pretty close
              {
                //ought to be parked on right point
                
                timingZeroStep= 10*degRF;     //overshoot a bit
                timingZero-= timingZeroStep;  //displace so begin working back toward estimated point
                
                show1step(rfdevice->state,"(3of3)timingZero=",timingZero/ns,"ns");
                  
                rfdevice->timeOffset= timingZero - timingPhase/rfdevice->omega;
                  
                if(verbose>1)
                  printf("kbb.3 timingZeroStep=%gdegRF timingZero=%gns\n",
                         timingZeroStep/degRF,timingZero/ns);

                AnotherPass= true;
              }
            else   //KBB - simple search about the method
              {
                G4bool same=true;  //try#3,4 ought to be close

                switch(method)
                  {
                  case AUTOTIMING_MAXENERGY:
                    same= chng.dE > previous.dE;
                    break;
                  case AUTOTIMING_NOENERGY:
                    same= fabs(chng.dE) < fabs(previous.dE);
                    break;
                  case AUTOTIMING_MINENERGY:
                    same= chng.dE < previous.dE;
                    break;
                  case AUTOTIMING_MAXTIME:
                    same= chng.dT > previous.dT;
                    break;
                  case AUTOTIMING_NOMTIME:
                    same= fabs(chng.dT) < fabs(previous.dT);
                    break;
                  case AUTOTIMING_MINTIME:
                    same= chng.dT < previous.dT;
                    break;
                  case AUTOTIMING_NODXP:
                    same= fabs(chng.Xdefl) < fabs(previous.Xdefl);
                    break;
                  case AUTOTIMING_MAXDXP:
                    same= chng.Xdefl > previous.Xdefl;
                    break;
                  case AUTOTIMING_MINDXP:
                    same= chng.Xdefl < previous.Xdefl;
                    break;
                  case AUTOTIMING_NODYP:
                    same= fabs(chng.Ydefl) < fabs(previous.Ydefl);
                    break;
                  case AUTOTIMING_MAXDYP:
                    same= chng.Ydefl > previous.Ydefl;
                    break;
                  case AUTOTIMING_MINDYP:
                    same= chng.Ydefl < previous.Ydefl;
                    break;
                  default:
                    break;
                  }
                
                show1step(rfdevice->state,"timingzero=",timingZero/ns,"ns");

                AnotherPass= fabs(timingZeroStep) > rfdevice->timingTolerance;          
                
                if(AnotherPass)
                  {
                    if(!same)  timingZeroStep/= -1.5;     //backup and reverse direction, 2/3 step size
                    timingZero+= timingZeroStep;
                  }

                if(verbose>1)
                  printf("kbb.%d timingZeroStep=%gns Another=%s negativeParticle=%s\n",
                         timeCount,timingZeroStep/ns,AnotherPass?"y":"n",
                         negativeParticle?"Y":"N");
              }

            if(AnotherPass)
              {
                rfdevice->timeOffset= timingZero - timingPhase/rfdevice->omega;  //adjustment point
                rfdevice->state= ATWORKING_OFFSET; //continue on
              }
            else
              {
                /* 
                   the definition of 0degRF is the zero crossing on the rising slope,
                   independent of the sign of the particle 
                */

                //bracket -RFperiod/2<timingZero<+RFperiod/2
                while(timingZero>RFperiod/2) timingZero-= RFperiod;
                while(timingZero<-RFperiod/2) timingZero+= RFperiod;

                rfdevice->timeOffset= timingZero; 

                rfdevice->state= ATWORKING_BASE;  //set next pass at 0degRF
              }
          }

        break;
      }

    case ATWORKING_BYPASS:   //base timeOffset set explicitly
      {
        show1step(rfdevice->state,"timingzero=",timingZero/ns,"ns");

        timingZero= rfdevice->timeOffset;  //time explicitly fixed
        timingPhase= 0;

        if(rfdevice->what2adjust==AUTOADJUST_GRADIENT)
          {
            rfdevice->state= ATWORKING_BASE;
          }
        else  //nothing left to adjust
          {
            rfdevice->state= ATWORKING_FINAL;

            if(rfdevice->whatFixed & ATFIX_OFFSETINCR)  
              rfdevice->timeOffset= rfdevice->timeOffset+= rfdevice->timeIncrement;
          }

        break;
      }

    case ATWORKING_BASE:  //ought to be final 0degRF baseline
      {
        /* 
           Because 0degRF is DEFINED to be when voltage is at zero crosing and
           rising with a postive slope, for both positive and negative reference
           particles, the BASE ought to show a zero crossing with a rising slope. KBB
        */

        show1step(rfdevice->state,"timingZero=",timingZero/ns,"ns");

        base= step2snapshot(step, rfdevice->timeOffset, rfdevice->LtimingVolume, rotation, true);
        
        AutoTimingChange diba= autoTimingIn2Out(entrance, base);
        
        //set approximate value to satisfy conditions
        
        switch(rfdevice->what2adjust)
          {
          case AUTOADJUST_OUTPUT:   //fixed gradient and phase
            {
              timingPhase= rfdevice->phaseAcc;
              rfdevice->timeOffset= timingZero - rfdevice->phaseAcc/rfdevice->omega;

              if(verbose>1)
                printf("kbb.%d BASE - adjust output phaseAcc=%gdegRF\n",timeCount,rfdevice->phaseAcc/deg);

              rfdevice->state= ATWORKING_FINAL;  //done adjusting

              if(rfdevice->whatFixed & ATFIX_OFFSETINCR)  
                rfdevice->timeOffset+= rfdevice->timeIncrement;

              break;
            }
            
          case AUTOADJUST_PHASE:    //fixed gradient and output
            {
              double signal=0;
              
              if(BLCommand::isUndefined(ampl))
                {
                  signal= 0;  //just start from base
                }
              else if(rfdevice->whatFixed & ATFIX_P)  //estimate P swing from dE swing
                {
                  double Eo= sqrt(base.Ptot*base.Ptot+entrance.m*entrance.m);
                  ampl= sqrt((Eo+ampl)*(Eo+ampl)-entrance.m*entrance.m) - base.Ptot;
                  signal= (rfdevice->autoTimingFixP - base.Ptot)/ampl;
                }
              else if(rfdevice->whatFixed & ATFIX_DE)  //base.DE ~ 0
                {
                  signal= (rfdevice->autoTimingFixDE - diba.dE)/ampl;
                }
              else if(rfdevice->whatFixed & ATFIX_DT)  //total transit times
                {
                  signal= (rfdevice->autoTimingFixDT - diba.dT)/ampl;
                }
              else if(rfdevice->whatFixed & ATFIX_XDEFL)  //base.Xdefl ~ 0
                {
                  signal= (rfdevice->autoTimingFixXdeflection - diba.Xdefl)/ampl;
                }
              else if(rfdevice->whatFixed & ATFIX_YDEFL)  //base.Ydefl ~ 0
                {
                  signal= (rfdevice->autoTimingFixYdeflection - diba.Ydefl)/ampl;
                }
              
              if(signal>1.)
                signal= 1.;
              else if(signal<-1.)
                signal= -1.;

              timingPhase= asin(signal);

              if(negativeParticle)  timingPhase+= pi;

              if(verbose>1)
                printf("kbb.%d BASE - ampl=%g signal=%g timingPhase=%gdegRF\n",
                       timeCount,ampl,signal,timingPhase/deg);
              
              rfdevice->timeOffset= timingZero - timingPhase/rfdevice->omega;
              
              rfdevice->state= ATWORKING_ESTIMATE;  //best guess at phase
              break;
            }
            
          case AUTOADJUST_GRADIENT:    //fixed phase and output
            {
              //currently at phase 0, so no energy gain... reuse estimate

              timingPhase= rfdevice->phaseAcc;

              if(rfdevice->whatFixed & ATFIX_PHASE)
                {
                  rfdevice->timeOffset= timingZero - rfdevice->phaseAcc/rfdevice->omega;  //fixed phase & timing
                  timingPhase= rfdevice->phaseAcc;
                }
              else if(rfdevice->whatFixed & ATFIX_OFFSET)
                {
                  timingZero= rfdevice->timeOffset;
                  timingPhase= 0;
                }
              else   //ought to have phaseAcc or timeOffset set
                {
                  rfdevice->timeOffset= timingZero;
                  timingPhase= 0;
                }

              timingGrad= rfdevice->maxGradient;
              rfdevice->state= ATWORKING_ESTIMATE;  //best guess at gradient

              if(verbose>1)
                {
                  printf("kbb:ROI:(%s) estimated maxGradient=%.6f MV/m\n", 
                         pbname, rfdevice->maxGradient/(megavolt/meter));
                }

              break;
            }

          case AUTOADJUST_UNKNOWN:
          case AUTOADJUST_UNNEEDED:
            break;
          }
        
        break;
      }
      
    case ATWORKING_ESTIMATE:     //extrapolated
      {
        estimate= step2snapshot(step, rfdevice->timeOffset, rfdevice->LtimingVolume, rotation, true);
        
        AutoTimingChange dies= autoTimingIn2Out(entrance, estimate);
        
        switch(rfdevice->what2adjust)
          {
          case AUTOADJUST_PHASE:    //fixed gradient and output
            {
              show1step(rfdevice->state,"timingZero=",timingZero/ns,"ns");
              timingPhaseStep= 5*deg;         //back off a little
              timingPhase-= timingPhaseStep;  //displace so begin working back toward estimated point   
              rfdevice->timeOffset= timingZero - timingPhase/rfdevice->omega;
              rfdevice->state= ATWORKING_FINETUNE;
              rfdevice->phaseAcc= timingPhase; //FYI only - determined by timeOffset

              if(verbose>1)
                {
                  printf("kbb.%d estimate (shift 10deg) timingPhaseStep=%gdegRF timingPhase=%gdegRF\n", 
                         timeCount, timingPhaseStep/deg, timingPhase/deg);
                }

              break;
            }
            
          case AUTOADJUST_GRADIENT:    //fixed phase and output
            {
              show1step(rfdevice->state,"timingGrad=",timingGrad/(megavolt/meter),"MV/m");
              timingGradStep= timingGrad/3;  
              timingGrad-= timingGradStep;  //displace so begin working back toward estimated point
              rfdevice->maxGradient= timingGrad;
              rfdevice->state= ATWORKING_FINETUNE;

              if(verbose>1)
                {
                  printf("kbb.%d estimate (shift 1/3) timingGradStep=%gMV/m timingGrad=%gMV/m\n",
                         timeCount, timingGradStep/(megavolt/meter), timingGrad/(megavolt/meter));
                }

              break;
            }

          case AUTOADJUST_UNKNOWN:  //ought to have been handled already
          case AUTOADJUST_UNNEEDED:
          case AUTOADJUST_OUTPUT:   //ought to have been handled already
            {
              show1step(rfdevice->state,"timeOffset=",rfdevice->timeOffset/ns,"ns");

              rfdevice->state= ATWORKING_FINAL;  //done adjusting

              if(rfdevice->whatFixed & ATFIX_OFFSETINCR)  
                rfdevice->timeOffset+= rfdevice->timeIncrement;

              if(verbose>1)
                {
                  printf("kbb.%d estimate? what2adjust=0x%X\n", timeCount, rfdevice->what2adjust);
                }

              break;
            }         
          }

        break;
      }
      
    case ATWORKING_FINETUNE:  //fine tune
      {
        //offset has been determined; working on adjustments from there
        //start parked at predicted phase
        
        G4double doup=0,dout=0;  //diffence between previous,current goal and result
        
        if(rfdevice->whatFixed & ATFIX_P)
          {
            dout= chng.Pout - rfdevice->autoTimingFixP;
            doup= previous.Pout - rfdevice->autoTimingFixP;
            show1step(rfdevice->state,"Pout=",chng.Pout/MeV,"MeV/c");
          }
        else if(rfdevice->whatFixed & ATFIX_DE)
          {
            dout= chng.dE - rfdevice->autoTimingFixDE;
            doup= previous.dE - rfdevice->autoTimingFixDE;
            show1step(rfdevice->state,"dE=",chng.dE/MeV,"MeV");
          }
        else if(rfdevice->whatFixed & ATFIX_DT)
          {
            dout= chng.dT - rfdevice->autoTimingFixDT;
            doup= previous.dT - rfdevice->autoTimingFixDT;
            show1step(rfdevice->state,"dT=",chng.dT/ns,"ns");
          }
        else if(rfdevice->whatFixed & ATFIX_XDEFL)
          {
            dout= chng.Xdefl - rfdevice->autoTimingFixXdeflection;
            doup= previous.Xdefl - rfdevice->autoTimingFixXdeflection;
            show1step(rfdevice->state,"dX=",chng.Xdefl/deg,"deg");
          }
        else if(rfdevice->whatFixed & ATFIX_YDEFL)
          {
            dout= chng.Ydefl - rfdevice->autoTimingFixYdeflection;
            doup= previous.Ydefl - rfdevice->autoTimingFixYdeflection;
            show1step(rfdevice->state,"dY=",chng.Ydefl/deg,"deg");
          }
        else
          {
            show1step(rfdevice->state,"dE=",chng.dE/MeV,"MeV");
          }

        G4double same= fabs(dout) < fabs(doup);    //KBB - simple search 
        
        switch(rfdevice->what2adjust)
          {
          case AUTOADJUST_PHASE:    //fix gradient & output
            {
              AnotherPass= fabs(timingPhaseStep/rfdevice->omega) > rfdevice->timingTolerance ||
                fabs(dout) > rfdevice->autoTimingFailureLimit;
              
              if(AnotherPass)
                {
                  if(!same)  timingPhaseStep/= -1.5;  //backup and reverse direction, reduce step size
                  timingPhase+= timingPhaseStep;
                  rfdevice->timeOffset= timingZero - timingPhase/rfdevice->omega;

                  if(verbose>1)
                    {
                      printf("kbb.%d FINETUNE timingPhaseStep=%gdeg timingPhase=%.9fdeg Another=Y\n", 
                             timeCount, timingPhaseStep/deg, timingPhase/deg);
                    }
                }
              else
                {
                  if(verbose>1)
                    {
                      printf("kbb.%d FINETUNE timingPhase=%.9fdeg Another=N\n", 
                             timeCount,timingPhase/deg);
                    }

                  rfdevice->state= ATWORKING_FINAL;  //done adjusting

                  if(rfdevice->whatFixed & ATFIX_OFFSETINCR)  
                    rfdevice->timeOffset= rfdevice->timeOffset+= rfdevice->timeIncrement;
                }
              
              break;
            }
            
          case AUTOADJUST_GRADIENT:
            {
              AnotherPass= fabs(dout) > rfdevice->autoTimingFailureLimit;
              
              if(AnotherPass)
                {
                  if(!same)  timingGradStep/= -1.5;     //backup and reverse direction, decrease step size
                  timingGrad+= timingGradStep;
                  rfdevice->maxGradient= timingGrad;

                  if(verbose>1)
                    {
                      printf("kbb.%d FINETUNE timingGradStep=%gMV/m timingGrad=%.9fMV/m Another=Y\n", 
                             timeCount, timingGradStep/(megavolt/meter), timingGrad/(megavolt/m));
                    }
                }
              else
                {
                  if(!RevisitTimingAfterGradientAdjust || revisited_timingZero)
                    {
                      if(verbose>1)
                        {
                          printf("kbb.%d FINETUNE timingGrad=%.9fMV/m Another=N Revisit=N\n", 
                                 timeCount, timingGrad/(megavolt/m));
                        }

                      lastFound_maxGradient= rfdevice->maxGradient= timingGrad;

                      rfdevice->state= ATWORKING_FINAL;  //done adjusting

                      if(rfdevice->whatFixed & ATFIX_OFFSETINCR)  
                        rfdevice->timeOffset+= rfdevice->timeIncrement;
                    }
                  else  //start all over deterimining timeZero, but using current gradient
                    {         
                      rfdevice->state= ATWORKING_OFFSET;
                      rfdevice->timeOffset= timingZero= 0;
                      timingPhase= automethod2timingphase(method, entrance.q);  //reset
                      revisited_timingZero= true;
                      timeCount000= timeCount;  //last of 1st of 2 passes

                      if(verbose>1)
                        {
                          printf("kbb.%d:STARTOVER:(%s) start over using maxGradient=%.6f MV/m\n", 
                                 timeCount, pbname, rfdevice->maxGradient/(megavolt/meter));
                        }
                    }
                }

              break;
            }
          case AUTOADJUST_UNKNOWN:  //ought to have been done already
          case AUTOADJUST_UNNEEDED:
          case AUTOADJUST_OUTPUT:   //ought to have been done already
            {
              if(verbose>1)
                {
                  printf("kbb.%d FINETUNE - don't know what?\n", timeCount);
                }

              rfdevice->state= ATWORKING_FINAL;  //done adjusting

              if(rfdevice->whatFixed & ATFIX_OFFSETINCR)  
                rfdevice->timeOffset+= rfdevice->timeIncrement;

              break;
            }
          }

        break;
      }
      
    case ATWORKING_FINAL:   //found solution, but need to do one more pass to update all
      {
        G4bool ok=true;
        if(BLCommand::isUndefined(rfdevice->autoTimingFailureLimit))
          {
            ok= true;
          }
        else if(rfdevice->whatFixed & ATFIX_P)
          {
            ok= fabs(rfdevice->autoTimingFixP-chng.Pout)/MeV <  rfdevice->autoTimingFailureLimit;
            show1step(rfdevice->state,"Pout=",chng.Pout/MeV,"MeV/c");
          }
        else if(rfdevice->whatFixed & ATFIX_DE)
          {
            ok= fabs(rfdevice->autoTimingFixDE-chng.dE)/MeV <  rfdevice->autoTimingFailureLimit;
            show1step(rfdevice->state,"dE=",chng.dE/MeV,"MeV");
          }
        else if(rfdevice->whatFixed & ATFIX_DT)
          {
            ok= fabs(rfdevice->autoTimingFixDT-chng.dT)/ns <  rfdevice->autoTimingFailureLimit;
            show1step(rfdevice->state,"dT=",chng.dT/ns,"ns");
          }
        else if(rfdevice->whatFixed & ATFIX_XDEFL)
          {
            ok= fabs(rfdevice->autoTimingFixXdeflection-chng.Xdefl)/deg <  rfdevice->autoTimingFailureLimit;
            show1step(rfdevice->state,"dX=",chng.Xdefl,"deg");
          }
        else if(rfdevice->whatFixed & ATFIX_YDEFL)
          {
            ok= fabs(rfdevice->autoTimingFixYdeflection-chng.Ydefl)/deg <  rfdevice->autoTimingFailureLimit;
            show1step(rfdevice->state,"dY=",chng.Ydefl,"deg");
          }
        else
          {
            show1step(rfdevice->state,"dE=",chng.dE/MeV,"MeV");
          }     
        
        printf("rfdevice::autoTiming:%d",redo);

        printf("[%s,%.1fdeg]ok=%s %s ",
               automethod2text(method), automethod2timingphase(method,entrance.q)/deg,
               ok? "Yes":"No", pbname);
        
        printf("timeOffset=%.9fns", rfdevice->timeOffset/ns);

        if(rfdevice->whatFixed & ATFIX_OFFSETINCR)
          printf("{timeIncrement=%.9fns}",rfdevice->timeIncrement/ns);
        
        printf(",maxGradient=%gMV/m,phaseAcc=%gdegRF -> ",
               rfdevice->maxGradient/(megavolt/meter),rfdevice->phaseAcc/deg);
        
        printf("%gMeV/c,%gMeV,%gns,%gXdeg,%gYdeg ",
               chng.Pout/MeV,chng.dE/MeV,chng.dT/ns,chng.Xdefl/deg,chng.Ydefl/deg);
        
        printf("timingZero=%.6fns,exit@%gmm,%gmm,%gmm,%gns\n",
               timingZero/ns,exit.x/mm,exit.y/mm,exit.z/mm,exit.t/ns);

        if(!ok)
            G4Exception("rfdevice","Final fixed value out of limits",FatalException,"");  //abort

        TrackOfInterest= true;

        if(verbose>1)
          {
            printf("kbb.%d FINAL - all done\n", timeCount);
            fflush(stdout);
          }

        /* lock final values into rfdevicefield, as copies of rfdevicefield reuse rfdevice... */
        maxGradient= rfdevice->maxGradient;
        timeOffset= rfdevice->timeOffset;
        stateOfPlacement= rfdevice->state= ATWORKING_DONE;
        break;
      }

    case ATWORKING_DONE:  
      {
        maxGradient= rfdevice->maxGradient;
        timeOffset= rfdevice->timeOffset;
        stateOfPlacement= rfdevice->state= ATWORKING_DONE;
        return; /* continue onward */
      } 
      
    case ATWORKING_UNKNOWN:  //never ought to happen
    case ATWORKING_INFLUX:
    case ATWORKING_RESET:
    default:
      {
        if(verbose>1)
          {
            printf("kbb.%d FINAL - ought not to be here\n", timeCount);
          }
      }

      return;
    }

    previous= chng;
 
    // restore saved data (i.e. jump back to when the track 
    // first entered TimingVol)

    if(!validSaveTrack)
      G4Exception("rfdevice","Invalid Step",FatalException,"");
 
    track->SetTrackStatus(fStopAndKill);  //kill off current track

    steppingMgr->GetfSecondary()->push_back(new G4Track(saveTrack));  //KBB* g4bl 2.06-2.08 change
 
    if(verbose>0)  fflush(stdout);

    return;
}

void RFdeviceField::show1step	(	AutoTimingState	state,
		const char *	pre,
		G4double	wrkval,
		const char *	suf
	)

show1step() prints handy messages about autoTiming

References ATFIX_DE, ATFIX_DT, ATFIX_GRADIENT, ATFIX_OFFSET, ATFIX_OFFSETINCR, ATFIX_OUTPUT, ATFIX_P, ATFIX_PHASE, ATFIX_XDEFL, ATFIX_YDEFL, ATWORKING_BASE, ATWORKING_DONE, ATWORKING_ESTIMATE, ATWORKING_FINAL, ATWORKING_FINETUNE, ATWORKING_UNKNOWN, AUTOADJUST_GRADIENT, AUTOADJUST_OUTPUT, AUTOADJUST_PHASE, AUTOADJUST_UNKNOWN, automethod2text(), autotiming2method(), BLCMDrfdevice::autoTimingFixDE, BLCMDrfdevice::autoTimingFixDT, BLCMDrfdevice::autoTimingFixP, BLCMDrfdevice::autoTimingFixXdeflection, BLCMDrfdevice::autoTimingFixYdeflection, BLCMDrfdevice::autoTimingMethod, autotimingstate2text(), BLCMDrfdevice::autoTimingZlocal, global_2TraceCounter, BLCommand::isUndefined(), BLCMDrfdevice::maxGradient, pbname, BLCMDrfdevice::phaseAcc, rfdevice, stateOfPlacement, timeCount, BLCMDrfdevice::timeIncrement, BLCMDrfdevice::timeOffset, timingPhase, BLCMDrfdevice::verbose, BLCMDrfdevice::what2adjust, and BLCMDrfdevice::whatFixed.

Referenced by UserSteppingAction().

{
  //show info on current autoTiming step

  if(!rfdevice->verbose)  return;

  int g= global_2TraceCounter;  //problems printing I*8

  printf("kbb_{%s}_%d:-2.%d:%s->%s ",pbname,timeCount,g,
         autotimingstate2text(stateOfPlacement),autotimingstate2text(state));

  //alltrace numbers UserSteppingActions as Event#-2.1,-2.1000,-2.1001,...
  if(global_2TraceCounter<1000)
    global_2TraceCounter= 1000;
  else
    ++global_2TraceCounter; 

  G4int fx= rfdevice->whatFixed & ~ATFIX_OUTPUT;

  if(state==ATWORKING_UNKNOWN && fx!=0)
    {
      printf("fixed:");
      if(fx & ATFIX_OFFSET)  printf("%gnS",rfdevice->timeOffset/ns);
      fx&= ~ATFIX_OFFSET;

      if(fx & ATFIX_OFFSETINCR)
        printf("timeIncrement=%gnS",rfdevice->timeIncrement/ns);

      fx&= ~ATFIX_OFFSETINCR;

      if(fx!=0)  printf(",");
      if(fx & ATFIX_GRADIENT)  printf("%gMV/m",rfdevice->maxGradient/(megavolt/meter));
      fx&= ~ATFIX_GRADIENT;
      if(fx!=0)  printf(",");
      if(fx & ATFIX_PHASE)  printf("%gdegRF",rfdevice->phaseAcc/deg);
      fx&= ~ATFIX_PHASE;
      if(fx!=0)  printf(",");
      if(fx & ATFIX_DE)  printf("%gMeV",rfdevice->autoTimingFixDE/MeV);
      fx&= ~ATFIX_DE;
      if(fx!=0)  printf(",");
      if(fx & ATFIX_P)  printf("%gMeV/c",rfdevice->autoTimingFixP/MeV);
      fx&= ~ATFIX_P;
      if(fx!=0)  printf(",");
      if(fx & ATFIX_DT)  printf("%gns",rfdevice->autoTimingFixDT/ns);
      fx&= ~ATFIX_DT;
      if(fx!=0)  printf(",");
      if(fx & ATFIX_XDEFL)  printf("%gdegX",rfdevice->autoTimingFixXdeflection/deg);
      fx&= ~ATFIX_XDEFL;
      if(fx!=0)  printf(",");
      if(fx & ATFIX_YDEFL)  printf("%gdegY",rfdevice->autoTimingFixYdeflection/deg);
      fx&= ~ATFIX_YDEFL;
      if(fx!=0)  printf(",");
    }

  AutoTimingMethod mthd= autotiming2method( rfdevice->autoTimingMethod);
  printf("%s",automethod2text(mthd));
  if(!BLCommand::isUndefined(rfdevice->autoTimingZlocal))
    printf(",atZlocal=%gmm ",rfdevice->autoTimingZlocal);
  else
    printf(" ");

  printf("%s", 
         rfdevice->what2adjust==AUTOADJUST_UNKNOWN ? "AUTOADJUST_UNKNOWN" :
         rfdevice->what2adjust==AUTOADJUST_PHASE ? "AUTOADJUST_PHASE" :
         rfdevice->what2adjust==AUTOADJUST_GRADIENT ? "AUTOADJUST_GRADIENT" :
         rfdevice->what2adjust==AUTOADJUST_OUTPUT ? "AUTOADJUST_OUTPUT" : "?");

  if(rfdevice->what2adjust==AUTOADJUST_GRADIENT)
    {
      printf("=%gMV/m ",rfdevice->maxGradient/(megavolt/meter));
    }
  else if(rfdevice->what2adjust==AUTOADJUST_PHASE)
    {
      if(state==ATWORKING_ESTIMATE || state==ATWORKING_FINETUNE)
        {
          printf("=%gdegRF ",timingPhase/deg);  //FYI only
        }
      else if(state==ATWORKING_FINAL || state==ATWORKING_DONE)
        {
          printf("=%gdegRF ",rfdevice->phaseAcc/deg);  //FYI only
        }
      else if(state==ATWORKING_BASE)
        {
          printf("=0degRF ");  //phase temporarially set to zero for base tracking
        }
      else
        {
          printf(" ");
        }
    }
  else
    {
      printf(" ");
    }

  printf("%s%g%s\n",pre,wrkval,suf);
}

void RFdeviceField::reset

(

)

reset() resets various internal used by autoTime to initial settings

References ampl, ATWORKING_UNKNOWN, cycle, drift, maxGradient, revisited_timingZero, stateOfPlacement, timeCount, timeCount000, timeOffset, timingGrad, timingGradStep, timingPhase, timingPhaseStep, timingZero, timingZeroStep, BLCommand::undefined(), and validSaveTrack.

Referenced by UserSteppingAction().

{
        stateOfPlacement= ATWORKING_UNKNOWN;
        maxGradient= BLCommand::undefined();
        timeOffset= BLCommand::undefined();

        timeCount = 0;
        validSaveTrack = false;

        int timeCount000= 0;         
        G4bool revisited_timingZero= false;   
        double timingZero= 0;           
        double timingPhase= 0;           
        double timingZeroStep= 0;         
        double timingPhaseStep= 0;   
        double timingGrad= 0;       
        double timingGradStep=0;      
        int cycle= 0;              
        double ampl= 0;               
        double drift= 0;                 
}

---

Friends And Related Function Documentation

friend class BLCMDrfdevice [friend]

---

Member Data Documentation

G4String RFdeviceField::name [private]

Referenced by getName(), and RFdeviceField().

BLCMDrfdevice* RFdeviceField::rfdevice [private]

Referenced by addFieldValue(), BLCMDrfdevice::construct(), RFdeviceField(), show1step(), and UserSteppingAction().

G4VPhysicalVolume* RFdeviceField::timingPV [private]

Referenced by BLCMDrfdevice::construct(), RFdeviceField(), and UserSteppingAction().

BLCoordinateTransform RFdeviceField::global2local [private]

Referenced by addFieldValue(), BLCMDrfdevice::construct(), and RFdeviceField().

G4RotationMatrix* RFdeviceField::rotation [private]

Referenced by addFieldValue(), RFdeviceField(), and UserSteppingAction().

G4Track RFdeviceField::saveTrack [private]

Referenced by UserSteppingAction().

G4int RFdeviceField::timeCount [private]

Referenced by reset(), RFdeviceField(), show1step(), and UserSteppingAction().

G4bool RFdeviceField::validSaveTrack [private]

Referenced by reset(), RFdeviceField(), and UserSteppingAction().

BLFieldMap* RFdeviceField::fieldMap [private]

Referenced by addFieldValue(), RFdeviceField(), and UserSteppingAction().

AutoTimingMethod RFdeviceField::automethod [private]

AutoTimingState RFdeviceField::stateOfPlacement [private]

Referenced by reset(), RFdeviceField(), show1step(), and UserSteppingAction().

G4double RFdeviceField::maxGradient [private]

Referenced by addFieldValue(), reset(), RFdeviceField(), and UserSteppingAction().

G4double RFdeviceField::timeOffset [private]

Referenced by addFieldValue(), reset(), RFdeviceField(), and UserSteppingAction().

G4int RFdeviceField::redo [private]

Referenced by RFdeviceField(), and UserSteppingAction().

char RFdeviceField::pbname[256] [private]

Referenced by RFdeviceField(), show1step(), and UserSteppingAction().

int RFdeviceField::timeCount000 [private]

Referenced by reset(), RFdeviceField(), and UserSteppingAction().

G4bool RFdeviceField::revisited_timingZero [private]

Referenced by reset(), RFdeviceField(), and UserSteppingAction().

double RFdeviceField::timingZero [private]

Referenced by reset(), RFdeviceField(), and UserSteppingAction().

double RFdeviceField::timingPhase [private]

Referenced by reset(), RFdeviceField(), show1step(), and UserSteppingAction().

double RFdeviceField::timingZeroStep [private]

Referenced by reset(), RFdeviceField(), and UserSteppingAction().

double RFdeviceField::timingPhaseStep [private]

Referenced by reset(), RFdeviceField(), and UserSteppingAction().

double RFdeviceField::timingGrad [private]

Referenced by reset(), RFdeviceField(), and UserSteppingAction().

double RFdeviceField::timingGradStep [private]

Referenced by reset(), RFdeviceField(), and UserSteppingAction().

AutoTimingChange RFdeviceField::previous [private]

Referenced by UserSteppingAction().

int RFdeviceField::cycle [private]

Referenced by reset(), RFdeviceField(), and UserSteppingAction().

double RFdeviceField::ampl [private]

Referenced by reset(), RFdeviceField(), and UserSteppingAction().

double RFdeviceField::drift [private]

Referenced by reset(), RFdeviceField(), and UserSteppingAction().

AutoTimingSnapshot RFdeviceField::entrance [private]

Referenced by UserSteppingAction().

AutoTimingSnapshot RFdeviceField::exit [private]

Referenced by UserSteppingAction().

AutoTimingSnapshot RFdeviceField::base [private]

Referenced by UserSteppingAction().

AutoTimingSnapshot RFdeviceField::estimate [private]

Referenced by UserSteppingAction().

---

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

• BLCMDrfdevice.cc