BLCMDrfdevice Class Reference

Inheritance diagram for BLCMDrfdevice:

Detailed Description

BLCMDrfdevice implements an rfdevice.

Each placement of a BLCMDrfdevice creates an RFdeviceField that is linked into BLGlobalField. Each RFdeviceField sets its rfdevice->timeOffset via the timing particle (re-stepping through its TimingVol if necessary).

If fieldMapFile is non-null, it is read as a BLFieldMap and determines the peak field; both B and E are multiplied by maxGradient of the cavity.

Public Member Functions

BLCMDrfdevice ()

Default constructor. Defines the command, etc.

virtual ~BLCMDrfdevice ()

Destructor.

BLCMDrfdevice (const BLCMDrfdevice &r)

Copy constructor.

BLElement * clone ()

clone()

G4String commandName ()

commandName() returns "rfdevice".

int command (BLArgumentVector &argv, BLArgumentMap &namedArgs)

command() implements the rfdevice command.

void defineNamedArgs ()

defineNamedArgs() defines the named arguments of the command.

void argChanged ()

argChanged() does internal computations after some arg changed

void construct (G4RotationMatrix *relativeRotation, G4ThreeVector relativePosition, G4LogicalVolume *parent, G4String parentName, G4RotationMatrix *parentRotation, G4ThreeVector parentPosition)

construct() - construct the rfdevice. Creates a new RFdeviceField and adds it to BLGlobalField.

G4double getLength ()

getLength() returns the overallLength of the rfdevice

G4double getWidth ()

getWidth() returns the outer radius of the rfdevice

G4double getHeight ()

getHeight() returns the outer radius of the rfdevice

G4bool isOK ()

isOK() returns true only if all placed rfdevices of this type have had their timing set, and if the tuning (if used) converged.

G4bool trackOfInterest ()

trackOfInterest() returns true only if rfdevice timing just completed

void generatePoints (int npoints, std::vector< G4ThreeVector > &v)

generatePoints() from BLElement

G4bool isOutside (G4ThreeVector &local, G4double tolerance)

isOutside() from BLElement

Private Attributes

G4double maxGradient

G4double phaseAcc

G4String color

G4double frequency

G4double innerLength

G4double innerRadius

G4double pipeThick

G4double wallThick

G4String wallMat

G4double irisRadius

G4double collarRadialThick

G4double collarThick

G4double win1Thick

G4double win1OuterRadius

G4double win2Thick

G4String winMat

G4double skinDepth

G4double timingTolerance

G4double maxStep

G4String cavityMaterial

G4double timeIncrement

G4String fieldMapFile

G4double timeOffset

G4String autoTimingMethod

G4double autoTimingFixP

G4double autoTimingFixDE

G4double autoTimingFixDT

G4double autoTimingFixXdeflection

G4double autoTimingFixYdeflection

G4double autoTimingFailureLimit

G4double autoTimingZlocal

G4int verbose

G4int kill

AutoTimingState state

G4int whatFixed

AutoTimingWhatToAdjust what2adjust

G4double LtimingVolume

G4double overallLength

G4double outerRadius

G4double omega

G4double rFactor

G4double E2Bfactor

BLFieldMap * fieldMap

std::vector< RFdeviceField * > rfdeviceField

int changeCount

Friends

class RFdeviceField

Constructor & Destructor Documentation

BLCMDrfdevice::BLCMDrfdevice ( )

Default constructor. Defines the command, etc.

References ATWORKING_UNKNOWN, AUTOADJUST_UNKNOWN, autoTimingFailureLimit, autoTimingFixDE, autoTimingFixDT, autoTimingFixP, autoTimingFixXdeflection, autoTimingFixYdeflection, autoTimingMethod, autoTimingZlocal, BLCMDTYPE_ELEMENT, cavityMaterial, changeCount, collarRadialThick, collarThick, color, E2Bfactor, fieldMap, fieldMapFile, frequency, innerLength, innerRadius, irisRadius, kill, LtimingVolume, maxGradient, maxStep, omega, outerRadius, overallLength, phaseAcc, pipeThick, BLCommand::registerCommand(), rFactor, BLCommand::setDescription(), BLCommand::setSynopsis(), skinDepth, state, timeIncrement, timeOffset, timingTolerance, BLCommand::undefined(), verbose, wallMat, wallThick, what2adjust, whatFixed, win1OuterRadius, win1Thick, win2Thick, and winMat.

Referenced by clone(), and command().

00631                              : BLElement(), rfdeviceField()
00632 {
00633         // register the commandName(), and its synopsis and description.
00634         registerCommand(BLCMDTYPE_ELEMENT);
00635         setSynopsis("Defines an rfdevice (RF cavity)");
00636         setDescription("An rfdevice (RF cavity) is the basic RF element used to "
00637                 "construct a linac.  The G4beamline convention is that 0degRF is the positive "
00638                 "going zero crossing of the electric field, so generally phaseAcc=90 (degRF) is on-crest.\n\n"
00639 
00640                 "The timeOffset parameter, if set, fixes the overall global absolute timing of the cavity "
00641                 "relative to time=0 of the simulation.  If unspecified, 0degRF is determined via the "
00642                 "timingMethod setting.  The default, timingMethod=atZlocal, defines 0degRF such that the "
00643                 "test particle will arrive at the timingAtZ=# location then.\n\n"
00644 
00645                 "For longitudinal cavities, timingMethod=maxEnergyGain emulates how most cavities "
00646                 "in linacs have their overall timing determined; " 
00647                 "while maxX would be appropriate "
00648                 "for a horizontal transverse deflecting cavity.\n\n"
00649 
00650                 "Independent of how 0degRF is found, exactly two of the set of maxGradient, phaseAcc, "
00651                 "and one fixed output quantity (fixMomentum, fixEnergyGain, fixTransitTime, fixXdeflection, "
00652                 "or fixYdeflection) must be specified to deterimine the final rfdevice timing.  For example, "
00653                 "with maxGradient and phaseAcc set, the energy gain would be determined, while if maxGradient "
00654                 "and fixEnergyGain were set, the phaseAcc would be determined.\n\n"
00655                 
00656                 "The pipe, walls, and collars are made of copper by default. "
00657                 "Pipe, wall, collar, win1, and win2 may be omitted by setting their thickness to 0. "
00658                 "Common usage is to set the collar values such that, by placing multiple rfdevices sequentially, "
00659                 "the collars form a beam pipe between them.\n\n"
00660 
00661                 "Note that section 4.4 of the User's Guide has a dimensioned drawing of a pillbox. "
00662                 "Due to the presence of an (usually) invisible timing volume, care must be taken when placing "
00663                 "objects within an rfdevice.\n\n"
00664                 "See the User's Guide for details on how to use this complex "
00665                 "element.");
00666 
00667         // provide initial values for fields
00668         timeOffset = undefined();                //[ns] (includes phase)
00669         maxGradient = undefined();               //[MV/m] (peak field)
00670         phaseAcc = undefined();                  //[degRF] (90degRF==oncrest)
00671 
00672         color = "1.0,0.0,0.0";
00673         frequency = undefined();
00674         innerLength = undefined();
00675         innerRadius = undefined();
00676         pipeThick = 3.0*mm;
00677         wallThick = 3.0*mm;
00678         irisRadius = 11.0*cm;
00679         collarRadialThick = 5.0*mm;
00680         collarThick = 2.5*mm;
00681         win1Thick = 0.200*mm;
00682         win1OuterRadius = 5.0*cm;
00683         win2Thick = 0.500*mm;
00684         winMat = "Be";
00685         wallMat= "Cu";                           //KBB-15mar11: allow for other cavity metals
00686         skinDepth = 0.002*mm;
00687         timingTolerance = 0.001*ns;
00688         maxStep = -1.0;
00689         cavityMaterial = "Vacuum";
00690 
00691 
00692         autoTimingMethod= "atZlocal";             //KBB-9mar11: alternative tuning methods
00693         autoTimingZlocal= undefined();           //KBB  center of rfdevice in local coordinates
00694 
00695         autoTimingFixP = undefined();            //KBB: requested fixed |P| output 
00696         autoTimingFixDE = undefined();           //KBB: requested fixed dKE output
00697         autoTimingFixDT = undefined();           //KBB: requested fixed dT output
00698         autoTimingFixXdeflection = undefined();  //KBB: requested fixed local XZ angle
00699         autoTimingFixYdeflection = undefined();  //KBB: requested fixed local YZ angle
00700 
00701         autoTimingFailureLimit = 1.E-3;           //KBB: tolerable error between fixed setting and result
00702         verbose = 1;                    //KBB: display timing volume and print info
00703 
00704         timeIncrement = 0;
00705         fieldMapFile = "";
00706         kill = 0;
00707         // non-arguments:
00708         state= ATWORKING_UNKNOWN;               //may need reset later
00709         whatFixed= 0;                           //nothing yet
00710         what2adjust = AUTOADJUST_UNKNOWN;       //unknown yet
00711         overallLength = undefined();
00712         outerRadius = undefined();
00713         LtimingVolume= undefined();
00714         omega = undefined();
00715         rFactor = undefined();
00716         E2Bfactor = undefined();
00717         fieldMap = 0;
00718         changeCount= 0;
00719 }

virtual BLCMDrfdevice::~BLCMDrfdevice ( ) [inline, virtual]

Destructor.

00573 { }

BLCMDrfdevice::BLCMDrfdevice ( const BLCMDrfdevice & r )

Copy constructor.

References ATFIX_GRADIENT, ATFIX_OFFSET, ATFIX_PHASE, ATFIX_ZLOCAL, ATWORKING_UNKNOWN, autoTimingFailureLimit, autoTimingFixDE, autoTimingFixDT, autoTimingFixP, autoTimingFixXdeflection, autoTimingFixYdeflection, autoTimingMethod, autoTimingZlocal, cavityMaterial, changeCount, collarRadialThick, collarThick, color, BLTune::copyTunableArg(), E2Bfactor, fieldMap, fieldMapFile, frequency, innerLength, innerRadius, irisRadius, BLCommand::isUndefined(), kill, LtimingVolume, maxGradient, maxStep, omega, outerRadius, overallLength, phaseAcc, pipeThick, rFactor, skinDepth, state, timeIncrement, timeOffset, timingTolerance, BLCommand::undefined(), verbose, wallMat, wallThick, what2adjust, whatFixed, win1OuterRadius, win1Thick, win2Thick, and winMat.

00722                                                    : BLElement(r), rfdeviceField()
00723 {
00724         G4int whatFixedNow= r.whatFixed;
00725 
00726         // copy fields one at a time (transfers default values from the
00727         // default object to this new object).
00728 
00729         //allow maxGradient to be externally tuned if not autoTiming
00730         if(whatFixedNow & ATFIX_GRADIENT && !isUndefined(r.maxGradient)) 
00731           {
00732             BLTune::copyTunableArg(&maxGradient,&r.maxGradient);
00733           }
00734         else
00735           {
00736             whatFixedNow &= ~ATFIX_GRADIENT;
00737             maxGradient= undefined();
00738           }
00739 
00740         //allow timeOffset to be externally tuned if not autoTiming
00741         if(whatFixedNow & ATFIX_OFFSET && !isUndefined(r.timeOffset))
00742           {
00743             BLTune::copyTunableArg(&timeOffset,&r.timeOffset);
00744           }
00745         else
00746           {
00747             whatFixedNow &= ~ATFIX_OFFSET;
00748             timeOffset= undefined();
00749           }
00750 
00751         //do not allow phaseAcc to be tuned, as it's within timeOffset
00752         if(whatFixedNow & ATFIX_PHASE)
00753           phaseAcc = r.phaseAcc;
00754         else
00755           phaseAcc = undefined();
00756 
00757         color = r.color;
00758         frequency = r.frequency;
00759         innerLength = r.innerLength;
00760         innerRadius = r.innerRadius;
00761         pipeThick = r.pipeThick;
00762         wallThick = r.wallThick;
00763         wallMat = r.wallMat;
00764         irisRadius = r.irisRadius;
00765         collarRadialThick = r.collarRadialThick;
00766         collarThick = r.collarThick;
00767         win1Thick = r.win1Thick;
00768         win1OuterRadius = r.win1OuterRadius;
00769         win2Thick = r.win2Thick;
00770         winMat = r.winMat;
00771         skinDepth = r.skinDepth;
00772         timingTolerance = r.timingTolerance;
00773         maxStep = r.maxStep;
00774         cavityMaterial = r.cavityMaterial;
00775         fieldMapFile = r.fieldMapFile;
00776 
00777         timeIncrement = r.timeIncrement;
00778 
00779         autoTimingMethod = r.autoTimingMethod;
00780 
00781         if(whatFixedNow & ATFIX_ZLOCAL)
00782           autoTimingZlocal = r.autoTimingZlocal;
00783         else
00784           autoTimingZlocal = undefined();
00785 
00786         autoTimingFixP = r.autoTimingFixP;
00787         autoTimingFixDE = r.autoTimingFixDE;
00788         autoTimingFixDT = r.autoTimingFixDT;
00789         autoTimingFixXdeflection = r.autoTimingFixXdeflection;
00790         autoTimingFixYdeflection = r.autoTimingFixYdeflection;
00791 
00792         autoTimingFailureLimit = r.autoTimingFailureLimit;
00793         verbose = r.verbose;
00794 
00795         kill = r.kill;
00796 
00797         // non-arguments:
00798         state= ATWORKING_UNKNOWN;     //copies need to be updated individually
00799         whatFixed = whatFixedNow;   //possibly updated
00800         what2adjust = r.what2adjust;
00801         LtimingVolume = r.LtimingVolume;
00802         overallLength = r.overallLength;
00803         outerRadius = r.outerRadius;
00804         omega = r.omega;
00805         rFactor = r.rFactor;
00806         E2Bfactor = r.E2Bfactor;
00807         fieldMap = r.fieldMap;
00808         changeCount= r.changeCount;
00809 }

Member Function Documentation

BLElement* BLCMDrfdevice::clone ( ) [inline, virtual]

clone()

Implements BLElement.

References BLCMDrfdevice().

00579 { return new BLCMDrfdevice(*this); }

G4String BLCMDrfdevice::commandName ( ) [inline, virtual]

commandName() returns "rfdevice".

Implements BLCommand.

00582 { return "rfdevice"; }

int BLCMDrfdevice::command	(	BLArgumentVector &	argv,
		BLArgumentMap &	namedArgs
	)			`[virtual]`

command() implements the rfdevice command.

Implements BLCommand.

References argChanged(), ATWORKING_UNKNOWN, BLCMDrfdevice(), cavityMaterial, E, E2Bfactor, fieldMap, fieldMapFile, frequency, g4bl_exit(), BLCommand::getMaterial(), BLCommand::handleNamedArgs(), innerRadius, maxGradient, BLCommand::print(), BLCommand::printError(), BLFieldMap::readFile(), BLElement::setName(), and state.

00813 {
00814         // If the name of the cavity is "testUnits", perform the test and exit.
00815         if(argv[0] == "testUnits") {
00816                 // set the test case values, from Al Moretti's SuperFish example
00817                 maxGradient = 1.0 * megavolt/meter;
00818                 frequency = 0.956188/ns;
00819                 double Hcorrect = 1545.0; // A/m
00820                 double BcorrectTesla = 4.0*pi*1E-7 * Hcorrect; // MKS
00821                 argChanged();
00822                 // the first maximum of J1() has a value of 0.5819
00823                 double Bmax = maxGradient*E2Bfactor*0.5819;
00824                 printf("pillobx testUnits:\n           "         
00825                         "Freq(GHz)  Emax(MV/m)  Bmax(Tesla)  Radius(mm)\n");
00826                 printf("Values:  %10.4f %10.4f %12.4e %11.4f\n",
00827                         frequency/(1e9*hertz), maxGradient/(megavolt/meter),
00828                         Bmax/tesla, innerRadius/mm);
00829                 // these values already are in the correct units:
00830                 printf("Correct: %10.4f %10.4f %12.4e %8.1f\n",
00831                         0.956188,1.0,BcorrectTesla, 120.0);
00832                 printf("rfdevice testUnits: exiting\n");
00833                 g4bl_exit(0);
00834         }
00835 
00836         if(argv.size() != 1) {
00837                 printError("rfdevice: Invalid command, must have name");
00838                 return -1;
00839         }
00840 
00841         if(argv[0] == "default") {
00842                 return defaultRFdevice.handleNamedArgs(namedArgs);
00843         }
00844 
00845         BLCMDrfdevice *p = new BLCMDrfdevice(defaultRFdevice);
00846         p->state= ATWORKING_UNKNOWN;
00847         p->setName(argv[0]);
00848         int retval = p->handleNamedArgs(namedArgs);
00849 
00850         if(p->fieldMapFile != "") {
00851                 p->fieldMap = new BLFieldMap();
00852                 p->fieldMap->readFile(p->fieldMapFile);
00853         }
00854 
00855         // check material exists
00856         if(p->cavityMaterial.size() > 0) getMaterial(p->cavityMaterial,false);
00857 
00858         p->print(argv[0]);
00859 
00860         return retval;
00861 }

void BLCMDrfdevice::defineNamedArgs ( ) [virtual]

defineNamedArgs() defines the named arguments of the command.

Reimplemented from BLCommand.

References BLCommand::argDouble(), BLCommand::argInt(), BLCommand::argString(), BLCommand::argTunable(), autoTimingFailureLimit, autoTimingFixDE, autoTimingFixDT, autoTimingFixP, autoTimingFixXdeflection, autoTimingFixYdeflection, autoTimingMethod, autoTimingZlocal, cavityMaterial, collarRadialThick, collarThick, color, fieldMapFile, frequency, innerLength, innerRadius, irisRadius, kill, maxGradient, maxStep, phaseAcc, pipeThick, skinDepth, timeIncrement, timeOffset, timingTolerance, verbose, wallMat, wallThick, win1OuterRadius, win1Thick, win2Thick, and winMat.

00865 {
00866         argTunable(maxGradient,"maxGradient","The peak gradient of the cavity (MV/m)",megavolt/meter);
00867         argString(color,"color","The color of the cavity");
00868         argDouble(frequency,"frequency","The frequency of the cavity (GHz)",1/ns,"",false);
00869         argDouble(innerLength,"innerLength","The inside length of the cavity (mm)",mm,"",false);
00870         argDouble(innerRadius,"innerRadius","The inside radius of the cavity (mm)",mm,"",false);
00871         argDouble(pipeThick,"pipeThick","The thickness of the pipe wall (mm)",mm,"",false);
00872         argDouble(wallThick,"wallThick","The thickness of the cavity walls (mm)",mm,"",false);
00873         argString(wallMat,"wallMat","The material of all the walls [Cu]");
00874         argDouble(irisRadius,"irisRadius","The radius of the iris (mm)",mm,"",false);
00875         argDouble(collarRadialThick,"collarRadialThick","The radial thickness of the collar (mm)",mm,"",false);
00876         argDouble(collarThick,"collarThick","The thickness of the collar along z(mm)",mm,"",false);
00877         argDouble(win1Thick,"win1Thick","The thickness of the central portion of the\n"
00878                 "windows; zero for no window (mm)",mm,"",false);
00879         argDouble(win1OuterRadius,"win1OuterRadius","The radius of the central portion of\n"
00880                 "the windows (mm)",mm,"",false);
00881         argDouble(win2Thick,"win2Thick","The thickness of the outer portion of the\n"
00882                 "windows; zero for no window (mm)",mm,"",false);
00883         argString(winMat,"winMat","The material of the windows [Be].");
00884         argDouble(phaseAcc,"phaseAcc","The reference phase of the cavity (degrees).",deg);
00885         argDouble(skinDepth,"skinDepth","The skin depth (mm).",mm,"",false);
00886         argDouble(timingTolerance,"timingTolerance","Tolerance for timing tuning (ns)",ns);
00887         argDouble(maxStep,"maxStep","The maximum stepsize in the element (mm).",mm);
00888         argString(cavityMaterial,"cavityMaterial","Material of cavity volume [Vacuum].");
00889 
00890         argTunable(timeOffset,"timeOffset","Time offset for cavity [set via timingMethod] (ns).",ns);
00891         argDouble(timeIncrement,"timeIncrement","Increment to timeOffset, applied AFTER tuning. (ns).",ns);
00892 
00893         argString(autoTimingMethod,"timingMethod","Method for determining the nominal timeOffset "
00894                   "{atZ, maxE, noE, minE, maxT, nomT, minT, maxX, noX, minX, maxY, noY, minY}.");
00895 
00896         argDouble(autoTimingZlocal,"timingAtZ","Local Z location for timing (mm).",mm);
00897 
00898         argDouble(autoTimingFixP,"fixMomentum","Specify total output momentum (MeV/c).",MeV);
00899         argDouble(autoTimingFixDE,"fixEnergyGain","Specify energy gain (MeV).",MeV);
00900         argDouble(autoTimingFixDT,"fixTransitTime","Specify transit time (ns).",ns);
00901         argDouble(autoTimingFixXdeflection,"fixXdeflection","Specify local output XZ angle (deg).",deg);
00902         argDouble(autoTimingFixYdeflection,"fixYdeflection","Specify local output YZ angle (deg).",deg);
00903         argDouble(autoTimingFailureLimit,"fixTolerance","Specify allowable error on fixed settings [1.e-3].");
00904 
00905         argInt(verbose,"verbose","Set nonzero to show timing volume and print info messages [1].");
00906 
00907         argString(fieldMapFile,"fieldMapFile","Filename for BLFieldMap (pillbox if null).",false);
00908         argInt(kill,"kill","Set nonzero to kill tracks that hit the pipe, walls, or collars [0].");
00909 }

void BLCMDrfdevice::argChanged ( ) [virtual]

argChanged() does internal computations after some arg changed

Reimplemented from BLCommand.

References ATFIX_ANYOUT, ATFIX_DE, ATFIX_DT, ATFIX_GRADIENT, ATFIX_OFFSET, ATFIX_OFFSETINCR, ATFIX_OUTPUT, ATFIX_P, ATFIX_PHASE, ATFIX_XDEFL, ATFIX_YDEFL, ATFIX_ZLOCAL, ATWORKING_RESET, ATWORKING_UNKNOWN, AUTOADJUST_GRADIENT, AUTOADJUST_OUTPUT, AUTOADJUST_PHASE, AUTOADJUST_UNKNOWN, AUTOADJUST_UNNEEDED, autoTimingFixDE, autoTimingFixDT, autoTimingFixP, autoTimingFixXdeflection, autoTimingFixYdeflection, autoTimingZlocal, changeCount, collarThick, E2Bfactor, frequency, BLParam::getDouble(), howmanyfixed(), innerLength, innerRadius, BLCommand::isUndefined(), maxGradient, maxStep, omega, outerRadius, overallLength, Param, phaseAcc, pipeThick, BLCommand::printError(), rFactor, state, timeIncrement, timeOffset, BLCommand::undefined(), verbose, wallThick, what2adjust, whatFixed, win1Thick, and win2Thick.

Referenced by command(), and RFdeviceField::UserSteppingAction().

00913 {
00914         /* if called again, reinitialize */
00915 
00916         // compute non-argument variables
00917         omega = 2.0 * pi * frequency;
00918         if(isUndefined(innerRadius)) {
00919                 if(frequency > 0.0) {
00920                         // the first zero of J0(r) is at r=2.405
00921                         innerRadius =  2.405 / (omega/c_light);
00922                 } else {
00923                         printError("rfdevice: innerRadius is undefined");
00924                 }
00925         }
00926         double wall=collarThick;
00927         if(wallThick > wall) wall = wallThick;
00928         if(win1Thick > wall) wall = win1Thick;
00929         if(win2Thick > wall) wall = win2Thick;
00930         overallLength = innerLength + 2.0 * wall;
00931         outerRadius = innerRadius + pipeThick;
00932         rFactor = omega/c_light;
00933         // Previous versions had the incorrect value from the BeamTools:
00934         //     E2Bfactor = 1.0e-9 / c_light;   // MeV/m, MKS units
00935         // C.f. Eq. 8.77 in J.D.Jackson, _Classical_Electrodynamics_,
00936         //       first edition (1962). His value is 1/c in vacuum.
00937         E2Bfactor = 1.0/c_light;   // Geant4 units
00938         if(maxStep < 0.0) maxStep = Param.getDouble("maxStep");
00939 
00940 
00941         G4bool printTimingSteps=verbose>1;  //print misc info
00942 
00943         // whether quantities were specified or not;
00944         // set starting guesses if required
00945 
00946         if(state==ATWORKING_RESET)  //reset all
00947           {
00948             if(!(whatFixed & ATFIX_OFFSET))   timeOffset= undefined();
00949             if(!(whatFixed & ATFIX_GRADIENT))  maxGradient= undefined();
00950             if(!(whatFixed & ATFIX_PHASE))  phaseAcc= undefined();
00951             if(!(whatFixed & ATFIX_P))  autoTimingFixP= undefined();
00952             if(!(whatFixed & ATFIX_DE))  autoTimingFixDE= undefined();
00953             if(!(whatFixed & ATFIX_DT))  autoTimingFixDT= undefined();
00954             if(!(whatFixed & ATFIX_XDEFL))  autoTimingFixXdeflection= undefined();
00955             if(!(whatFixed & ATFIX_YDEFL))  autoTimingFixYdeflection= undefined();
00956             if(!(whatFixed & ATFIX_ZLOCAL))  autoTimingZlocal= undefined();
00957           }
00958 
00959         state= ATWORKING_UNKNOWN;     
00960         what2adjust= AUTOADJUST_UNKNOWN;
00961         G4int prevFixed= whatFixed;
00962         whatFixed= 0;  //reset
00963 
00964         G4bool setOffset= !isUndefined(timeOffset);
00965         G4bool setOffsetIncr= timeIncrement!=0;
00966         G4bool setGrad= !isUndefined(maxGradient);
00967         G4bool setPhase= !isUndefined(phaseAcc);
00968         G4bool setOff= !isUndefined(timeOffset);
00969         G4bool setP= !isUndefined(autoTimingFixP);
00970         G4bool setDE= !isUndefined(autoTimingFixDE);
00971         G4bool setDT= !isUndefined(autoTimingFixDT);
00972         G4bool setXd= !isUndefined(autoTimingFixXdeflection);
00973         G4bool setYd= !isUndefined(autoTimingFixYdeflection);
00974         G4bool setZ= !isUndefined(autoTimingZlocal);
00975 
00976         if(setOffset)  whatFixed |= ATFIX_OFFSET;
00977         if(setOffsetIncr)  whatFixed |= ATFIX_OFFSETINCR;
00978         if(setGrad)  whatFixed |= ATFIX_GRADIENT;
00979         if(setPhase)  whatFixed |= ATFIX_PHASE;
00980         if(setDE)  whatFixed |= ATFIX_DE;
00981         if(setP)  whatFixed |= ATFIX_P;
00982         if(setDT)  whatFixed |= ATFIX_DT;
00983         if(setXd)  whatFixed |= ATFIX_XDEFL;
00984         if(setYd)  whatFixed |= ATFIX_YDEFL;
00985         if(setZ)  whatFixed |= ATFIX_ZLOCAL;
00986 
00987         G4bool setFix= howmanyfixed(whatFixed) == 1;
00988         if(setFix)  whatFixed |= ATFIX_OUTPUT;  //ok output flag
00989 
00990 
00991         G4int justFixed= whatFixed & ~prevFixed;     //just newly fixed items
00992 
00993         int Njustfixed= howmanyfixed(justFixed);
00994 
00995         if(Njustfixed==1)  //retain only 1 fixed output - override any previous fixed outputs
00996           { //          remove old output              insert new output     ok output flag
00997             whatFixed= whatFixed & ~ATFIX_ANYOUT | justFixed & ATFIX_ANYOUT | ATFIX_OUTPUT; 
00998           }
00999         else if(Njustfixed>1)
01000           {
01001             G4Exception("argChanged:","Maximum of 1 fixed output allowed",FatalException,"");  //abort
01002           }
01003 
01004         if(setOffset && setGrad)
01005           {
01006             what2adjust= AUTOADJUST_UNNEEDED;
01007           }
01008         else if(setGrad && setPhase && !setFix)
01009           {
01010             what2adjust= AUTOADJUST_OUTPUT;
01011           }  
01012         else if(setGrad && !setPhase && setFix)
01013           {
01014             what2adjust= AUTOADJUST_PHASE;
01015           }
01016         else if(!setGrad && setPhase && setFix)
01017           {
01018             what2adjust= AUTOADJUST_GRADIENT;
01019           }
01020         else
01021           {
01022             what2adjust= AUTOADJUST_OUTPUT;
01023           }
01024                 
01025         if(printTimingSteps)
01026           {
01027             printf("BLCMDrfdevice::argChanged: changeCount=%d prevFixed=%d=%Xx justFixed=%d=%Xx ",
01028                    changeCount,prevFixed,prevFixed,justFixed,justFixed);
01029 
01030             printf("whatFixed=%d=%Xx\n",whatFixed,whatFixed);
01031 
01032             printf("setP=%d setDE=%d setDT=%d setXd=%d setYd=%d setGrad=%d ",
01033                    setP,setDE,setDT,setXd,setYd,setGrad);
01034 
01035             printf("setPhase=%d setFix=%d setOff=%d\n",setPhase,setFix,setOff);
01036             
01037             printf("usa:timeOffset=%g ns. gradient=%g MV/m phase=%g degRF\n", 
01038                    timeOffset/ns, maxGradient/(megavolt/meter), phaseAcc/deg);
01039             
01040             fflush(stdout);
01041           }
01042 
01043         /* Important to note that copies of rfdevice may be made later;
01044            so whatFixed and what2adjust ought not to be updated */
01045 
01046         ++changeCount;
01047 }

void BLCMDrfdevice::construct	(	G4RotationMatrix *	relativeRotation,
		G4ThreeVector	relativePosition,
		G4LogicalVolume *	parent,
		G4String	parentName,
		G4RotationMatrix *	parentRotation,
		G4ThreeVector	parentPosition
	)			`[virtual]`

construct() - construct the rfdevice. Creates a new RFdeviceField and adds it to BLGlobalField.

Implements BLElement.

References BLGlobalField::addElementField(), automethod2text(), autotiming2method(), AUTOTIMING_ATZ, autoTimingMethod, autoTimingZlocal, cavityMaterial, collarRadialThick, collarThick, color, BLCommand::getMaterial(), BLElement::getName(), BLGlobalField::getObject(), BLManager::getObject(), BLCoordinateTransform::getPosition(), BLCommand::getVisAttrib(), RFdeviceField::global2local, innerLength, innerRadius, irisRadius, BLCoordinateTransform::isRotated(), BLCommand::isUndefined(), kill, LtimingVolume, maxGradient, maxStep, phaseAcc, pipeThick, BLManager::registerTuneParticleStep(), RFdeviceField::rfdevice, rfdeviceField, RFdeviceField, timeOffset, RFdeviceField::timingPV, verbose, wallMat, wallThick, win1OuterRadius, win1Thick, win2Thick, and winMat.

01057 {
01058   if(verbose>1)
01059     {
01060       printf("BLCMDrfdevice::construct...1\n");
01061       fflush(stdout);
01062     }
01063 
01064         G4String thisname = parentName+getName();
01065 
01066         G4Material *cu = getMaterial(wallMat);   //KBB 15mar11- no longer just copper
01067         G4Material *wm = getMaterial(winMat);
01068         G4Material *cavityMat = getMaterial(cavityMaterial);
01069         G4UserLimits *userLimits = new G4UserLimits(maxStep);
01070 
01071         userLimits->SetUserMinRange(0.0001*mm); //KBB 31may11 - minimum step size
01072 
01073         // find enclosing Tubs
01074         G4double halflen = innerLength/2+wallThick;
01075         halflen = std::max(halflen,innerLength/2+collarThick);
01076         halflen = std::max(halflen,innerLength/2+win1Thick);
01077         halflen = std::max(halflen,innerLength/2+win2Thick);
01078         G4Tubs *tubs = new G4Tubs(getName(),0.0,innerRadius+pipeThick,
01079                                         halflen,0.0,2.0*pi);
01080         G4LogicalVolume *rfdevice = new G4LogicalVolume(tubs,cavityMat,
01081                                         parentName+getName(),0,0,userLimits);
01082 
01083   if(verbose>1)
01084     {
01085       printf("BLCMDrfdevice::construct...2\n");
01086       fflush(stdout);
01087     }
01088 
01089         G4ThreeVector loc;
01090         G4VPhysicalVolume *pv;
01091 
01092 
01093         // The outer pipe
01094         G4LogicalVolume *pipe=0;
01095         if(pipeThick > 0.001*mm) {
01096                 tubs = new G4Tubs(getName()+"pipe",innerRadius,
01097                                         innerRadius+pipeThick,
01098                                         innerLength/2+wallThick,0.0,2.0*pi);
01099                 pipe = new G4LogicalVolume(tubs,cu,
01100                                         getName()+"pipeLog",0,0,userLimits);
01101                 pv = new G4PVPlacement(0,loc,pipe,parentName+getName()+"Pipe",
01102                                         rfdevice,false,0);
01103                 if(kill) BLManager::getObject()->
01104                         registerSteppingAction(pv,new BLKillTrack(thisname));
01105         }
01106 
01107   if(verbose>1)
01108     {
01109       printf("BLCMDrfdevice::construct...2.1\n");
01110       fflush(stdout);
01111     }
01112 
01113         // the wall (us and ds) - radially: collarOuterRadius to innerRadius
01114         G4LogicalVolume *wall=0;
01115         if(wallThick > 0.001*mm) {
01116                 tubs = new G4Tubs(getName()+"wall",irisRadius+collarRadialThick,
01117                                         innerRadius,wallThick/2,0.0,2.0*pi);
01118                 wall = new G4LogicalVolume(tubs,cu,
01119                                         getName()+"wallLog",0,0,userLimits);
01120                 G4double wallCenterZ = innerLength/2.0 + wallThick/2.0;
01121                 loc.setZ(-wallCenterZ);
01122                 pv = new G4PVPlacement(0,loc,wall,parentName+getName()+"UsWall",
01123                                         rfdevice,false,0);
01124                 if(kill) BLManager::getObject()->
01125                         registerSteppingAction(pv,new BLKillTrack(thisname));
01126                 loc.setZ(+wallCenterZ);
01127                 pv = new G4PVPlacement(0,loc,wall,parentName+getName()+"DsWall",
01128                                         rfdevice,false,0);
01129                 if(kill) BLManager::getObject()->
01130                         registerSteppingAction(pv,new BLKillTrack(thisname));
01131         }
01132         
01133         // the collar (us and ds) - includes wall thickness (i.e. the inner
01134         // edge of the collar is the same as the inner edge of the wall)
01135         G4LogicalVolume *collar=0;
01136         if(collarThick > 0.001*mm) {
01137                 tubs = new G4Tubs(getName()+"collar",irisRadius,
01138                                         irisRadius+collarRadialThick,
01139                                         collarThick/2,0.0,2.0*pi);
01140                 collar = new G4LogicalVolume(tubs,cu,
01141                                         getName()+"collarLog",0,0,userLimits);
01142                 G4double collarCenterZ = innerLength/2.0 + collarThick/2.0;
01143                 loc.setZ(-collarCenterZ);
01144                 pv = new G4PVPlacement(0,loc,collar,parentName+getName()+"UsCollar",
01145                                         rfdevice,false,0);
01146                 if(kill) BLManager::getObject()->
01147                         registerSteppingAction(pv,new BLKillTrack(thisname));
01148                 loc.setZ(+collarCenterZ);
01149                 pv = new G4PVPlacement(0,loc,collar,parentName+getName()+"DsCollar",
01150                                         rfdevice,false,0);
01151                 if(kill) BLManager::getObject()->
01152                         registerSteppingAction(pv,new BLKillTrack(thisname));
01153         }
01154         
01155   if(verbose>1)
01156     {
01157       printf("BLCMDrfdevice::construct...2.2\n");
01158       fflush(stdout);
01159     }
01160 
01161         // win1 (the inner window)
01162         G4LogicalVolume *win1=0;
01163         if(win1Thick > 0.001*mm) {
01164                 tubs = new G4Tubs(getName()+"win1",0.0,win1OuterRadius,
01165                                         win1Thick/2,0.0,2.0*pi);
01166                 win1 = new G4LogicalVolume(tubs,wm,
01167                                         getName()+"win1Log",0,0,userLimits);
01168                 G4double win1CenterZ = innerLength/2.0 + win1Thick/2.0;
01169                 loc.setZ(-win1CenterZ);
01170                 new G4PVPlacement(0,loc,win1,parentName+getName()+"UsWin1",
01171                                         rfdevice,false,0);
01172                 loc.setZ(+win1CenterZ);
01173                 new G4PVPlacement(0,loc,win1,parentName+getName()+"DsWin1",
01174                                         rfdevice,false,0);
01175         }
01176 
01177   if(verbose>1)
01178     {
01179       printf("BLCMDrfdevice::construct...2.3 win2Thick=%g mm\n",win2Thick/mm);
01180       fflush(stdout);
01181     }
01182 
01183         // win2 (the outer window)
01184         G4LogicalVolume *win2=0;
01185         if(win2Thick > 0.001*mm) {
01186                 tubs = new G4Tubs(getName()+"win2",win1OuterRadius,irisRadius,
01187                                         win2Thick/2,0.0,2.0*pi);
01188                 win2 = new G4LogicalVolume(tubs,wm,
01189                                         getName()+"win2Log",0,0,userLimits);
01190                 G4double win2CenterZ = innerLength/2.0 + win2Thick/2.0;
01191                 loc.setZ(-win2CenterZ);
01192                 new G4PVPlacement(0,loc,win2,parentName+getName()+"UsWin2",
01193                                         rfdevice,false,0);
01194                 loc.setZ(+win2CenterZ);
01195                 new G4PVPlacement(0,loc,win2,parentName+getName()+"DsWin2",
01196                                         rfdevice,false,0);
01197         }
01198 
01199   if(verbose>1)
01200     {
01201       printf("BLCMDrfdevice::construct...3 autoTimingZlocal=");
01202       fflush(stdout);
01203       if(isUndefined(autoTimingZlocal))
01204         printf("undefined()\n");
01205       else
01206         printf("%g ns\n",autoTimingZlocal/ns);
01207     }
01208 
01209         G4double smidgen = 0.001*mm; //clearance
01210 
01211         AutoTimingMethod method= autotiming2method(autoTimingMethod);
01212 
01213         //generally atZlocal method uses Z located at center of cell
01214         //while other methods use near (a smidgen off) the exit of the rfdevice
01215 
01216         if(isUndefined(autoTimingZlocal))
01217           autoTimingZlocal= method==AUTOTIMING_ATZ ? 0.0 : innerLength/2; 
01218 
01219   if(verbose>1)
01220     {
01221       printf("BLCMDrfdevice::construct...3.1 method=%s autoTimingZlocal=%g mm\n",
01222              automethod2text(method), autoTimingZlocal/mm);
01223 
01224       fflush(stdout);
01225     }
01226 
01227         if(fabs(autoTimingZlocal) > innerLength/2)
01228           {
01229             printf(" autoTimingZlocal=%g mm\n",autoTimingZlocal/mm);
01230             fflush(stdout);
01231             G4Exception("rfdevice","timingAtZ outside of rfdevice!",FatalException,"");
01232           }
01233 
01234         if(verbose>1)
01235           {
01236             printf("BLCMDrfdevice::construct...3.5 autoTimingZlocal=%g mm\n",autoTimingZlocal/mm);
01237             fflush(stdout);
01238           }
01239 
01240         // nominal length from entrance to exit
01241 
01242         G4double Ltub = innerLength/2 + autoTimingZlocal;
01243 
01244   if(verbose>1)
01245     {
01246       printf("BLCMDrfdevice::construct...4 autoTimingZlocal=%g mm, Ltub=%g mm\n",autoTimingZlocal/mm,Ltub/mm);
01247       fflush(stdout);
01248     }
01249 
01250         //KBB In general, the "rfdevice" could be placed entirely within an RF structure
01251         //KBB (such as a 9-cell telsa cavity) - the drawback is that outside that
01252         //KBB massless rfdevice the fields are zero...
01253         //KBB If the structure were placed within the rfdevice, but outside the timing
01254         //KBB volume, the fields would have their full extent.
01255 
01256         G4double tV_radius = innerRadius/2; //only use 1/2 rfdevice radius
01257                                             //leave room for structures within rfdevice
01258 
01259         //reduce length from nominal just a little to avoid overlap issues
01260         LtimingVolume= Ltub-smidgen;
01261 
01262         tubs = new G4Tubs(getName()+"tiVo",0.0,tV_radius,LtimingVolume/2,0.0,2.0*pi);
01263         
01264         G4LogicalVolume *tiVo = new G4LogicalVolume(tubs,cavityMat,getName()+"tiVo",0,0,userLimits);
01265 
01266         loc.setZ(0.0);  //KBB - center of rfdevice
01267 
01268         loc.setZ((Ltub-innerLength)/2); //KBB - position upstream: begins just inside rfdevice entrance
01269 
01270         //timing volume used for timing the RF
01271 
01272         G4VPhysicalVolume *timingPV = new G4PVPlacement(0,loc,tiVo,
01273                                                         parentName+getName()+"tiVo",rfdevice,false,0);
01274 
01275         if(verbose>1)
01276           {
01277             printf("BLCMDrfdevice::construct...5 innerLength=%g mm, LtimingVolume=%g mm\n",innerLength,LtimingVolume/mm);
01278 
01279             printf("BLCMDrfdevice::construct...6 timeOffset=%g ns, phaseAcc=%g degRF, maxGradient=%g MV/m\n",
01280                    timeOffset/ns, phaseAcc/deg, maxGradient/(megavolt/meter));
01281 
01282             fflush(stdout);
01283           }
01284 
01285 #ifdef G4VIS_USE
01286         G4VisAttributes *c1 = new G4VisAttributes(true,G4Color(0.5,0.0,0.0));
01287         G4VisAttributes *c2 = new G4VisAttributes(true,G4Color(0.7,0.0,0.0));
01288         G4VisAttributes *c3 = new G4VisAttributes(true,G4Color(1.0,0.0,0.0));
01289         const G4VisAttributes *invisible = &G4VisAttributes::GetInvisible();
01290 
01291         if(color)   //KBB override default colors
01292           {
01293             if(pipe) pipe->SetVisAttributes(getVisAttrib(color));
01294             if(wall) wall->SetVisAttributes(getVisAttrib(color));
01295             if(collar) collar->SetVisAttributes(getVisAttrib(color));
01296             if(win1) win1->SetVisAttributes(getVisAttrib(color));
01297             if(win2) win2->SetVisAttributes(getVisAttrib(color));
01298           }
01299         else
01300           {
01301             if(pipe) pipe->SetVisAttributes(c1);
01302             if(wall) wall->SetVisAttributes(c1);
01303             if(collar) collar->SetVisAttributes(c1);
01304             if(win1) win1->SetVisAttributes(c3);
01305             if(win2) win2->SetVisAttributes(c2);
01306           }
01307 
01308         //KBB - timing volume shown as ghost grey smoke or invisible
01309         G4VisAttributes *smoke = new G4VisAttributes(true,G4Color(0.6,0.5,0.5,0.45));
01310 
01311         tiVo->SetVisAttributes(verbose>0 ? smoke : invisible); 
01312         rfdevice->SetVisAttributes(invisible);
01313 #endif
01314 
01315         // geant4 rotation convention is backwards from g4beamline
01316         G4RotationMatrix *g4rot = 0;
01317         if(relativeRotation)
01318                 g4rot = new G4RotationMatrix(relativeRotation->inverse());
01319 
01320         // place the rfdevice into the parent
01321         new G4PVPlacement(g4rot,relativePosition,rfdevice,
01322                                 parentName+getName(),parent,false,0);
01323 
01324         // get globalRotation and globalPosition
01325         G4RotationMatrix *globalRotation = 0;
01326         if(relativeRotation && parentRotation) {
01327                 globalRotation = 
01328                     new G4RotationMatrix(*parentRotation * *relativeRotation);
01329         } else if(relativeRotation) {
01330                 globalRotation = relativeRotation;
01331         } else if(parentRotation) {
01332                 globalRotation = parentRotation;
01333         }
01334         G4ThreeVector globalPosition(relativePosition + parentPosition);
01335         if(parentRotation)
01336                 globalPosition = *parentRotation * relativePosition +
01337                                 parentPosition;
01338 
01339         BLCoordinateTransform global2local(globalRotation,globalPosition);
01340 
01341         // add this rfdevice field to the GlobalField, and to BLManager
01342         G4double dz = innerLength/2.0 + wallThick;
01343         // if rotated, make an overestimate of the field occupancy along z
01344         if(global2local.isRotated())
01345                 dz += innerRadius;
01346         RFdeviceField *pf = 
01347                 new RFdeviceField(thisname,global2local,this,timingPV);
01348         BLGlobalField::getObject()->addElementField(pf);
01349         rfdeviceField.push_back(pf);
01350         BLManager::getObject()->registerTuneParticleStep(timingPV,pf);
01351 
01352         printf("BLCMDrfdevice::construct %s parent=%s relZ=%.1f globZ=%.1f\n"
01353                         "\tzmin=%.1f zmax=%.1f\n",
01354                 thisname.c_str(),parentName.c_str(),relativePosition[2],
01355                 global2local.getPosition()[2], global2local.getPosition()[2]-dz,
01356                 global2local.getPosition()[2]+dz);
01357 }

G4double BLCMDrfdevice::getLength ( ) [inline, virtual]

getLength() returns the overallLength of the rfdevice

Implements BLElement.

References overallLength.

00603 { return overallLength; }

G4double BLCMDrfdevice::getWidth ( ) [inline, virtual]

getWidth() returns the outer radius of the rfdevice

Implements BLElement.

References outerRadius.

00606 { return outerRadius*2.0; }

G4double BLCMDrfdevice::getHeight ( ) [inline, virtual]

getHeight() returns the outer radius of the rfdevice

Implements BLElement.

References outerRadius.

00609 { return outerRadius*2.0; }

G4bool BLCMDrfdevice::isOK ( ) [virtual]

isOK() returns true only if all placed rfdevices of this type have had their timing set, and if the tuning (if used) converged.

Implements BLElement.

References ATWORKING_DONE, rfdeviceField, and state2desc().

01361 {
01362         G4bool retval = true;
01363 
01364         // verify all placed rfdeviceField-s have set their timeOffset 
01365         std::vector<RFdeviceField *>::iterator i;
01366         for(i=rfdeviceField.begin(); i!=rfdeviceField.end(); ++i) 
01367           {
01368             if((*i)->stateOfPlacement!=ATWORKING_DONE) 
01369               {
01370                 printf("*** BLCMDrfdevice %s {%s->%s} has not determined everything\n",
01371                        (*i)->getName().c_str(),
01372                        state2desc((*i)->stateOfPlacement), 
01373                        state2desc((*i)->rfdevice->state));
01374 
01375                 retval = false;
01376               }
01377           }
01378 
01379         return retval;
01380 }

G4bool BLCMDrfdevice::trackOfInterest ( )

trackOfInterest() returns true only if rfdevice timing just completed

References TrackOfInterest.

01384 {
01385   //a flag to indicate this tuning track of the last pass
01386 
01387        return TrackOfInterest;
01388 }

void BLCMDrfdevice::generatePoints	(	int	npoints,
		std::vector< G4ThreeVector > &	v
	)			`[virtual]`

generatePoints() from BLElement

Implements BLElement.

References BLElement::generateTubs(), outerRadius, and overallLength.

01591 {
01592         generateTubs(npoints, 0.0, outerRadius, 0.0, 360.0*deg,
01593                         overallLength, v);
01594 }

G4bool BLCMDrfdevice::isOutside	(	G4ThreeVector &	local,
		G4double	tolerance
	)			`[virtual]`

isOutside() from BLElement

Implements BLElement.

References outerRadius, and overallLength.

01597 {
01598         G4double r = sqrt(local[0]*local[0]+local[1]*local[1]);
01599 
01600         return r > outerRadius-tolerance ||
01601                 fabs(local[2]) > overallLength/2.0-tolerance;
01602 }

Friends And Related Function Documentation

friend class RFdeviceField [friend]

Referenced by construct().

Member Data Documentation

G4double BLCMDrfdevice::maxGradient [private]

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

G4double BLCMDrfdevice::phaseAcc [private]

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

G4String BLCMDrfdevice::color [private]

Referenced by BLCMDrfdevice(), construct(), and defineNamedArgs().

G4double BLCMDrfdevice::frequency [private]

Referenced by RFdeviceField::addFieldValue(), argChanged(), BLCMDrfdevice(), command(), defineNamedArgs(), and RFdeviceField::UserSteppingAction().

G4double BLCMDrfdevice::innerLength [private]

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

G4double BLCMDrfdevice::innerRadius [private]

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

G4double BLCMDrfdevice::pipeThick [private]

Referenced by argChanged(), BLCMDrfdevice(), construct(), and defineNamedArgs().

G4double BLCMDrfdevice::wallThick [private]

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

G4String BLCMDrfdevice::wallMat [private]

Referenced by BLCMDrfdevice(), construct(), and defineNamedArgs().

G4double BLCMDrfdevice::irisRadius [private]

Referenced by BLCMDrfdevice(), construct(), and defineNamedArgs().

G4double BLCMDrfdevice::collarRadialThick [private]

Referenced by BLCMDrfdevice(), construct(), and defineNamedArgs().

G4double BLCMDrfdevice::collarThick [private]

Referenced by argChanged(), BLCMDrfdevice(), construct(), and defineNamedArgs().

G4double BLCMDrfdevice::win1Thick [private]

Referenced by argChanged(), BLCMDrfdevice(), construct(), and defineNamedArgs().

G4double BLCMDrfdevice::win1OuterRadius [private]

Referenced by BLCMDrfdevice(), construct(), and defineNamedArgs().

G4double BLCMDrfdevice::win2Thick [private]

Referenced by argChanged(), BLCMDrfdevice(), construct(), and defineNamedArgs().

G4String BLCMDrfdevice::winMat [private]

Referenced by BLCMDrfdevice(), construct(), and defineNamedArgs().

G4double BLCMDrfdevice::skinDepth [private]

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

G4double BLCMDrfdevice::timingTolerance [private]

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

G4double BLCMDrfdevice::maxStep [private]

Referenced by argChanged(), BLCMDrfdevice(), construct(), and defineNamedArgs().

G4String BLCMDrfdevice::cavityMaterial [private]

Referenced by BLCMDrfdevice(), command(), construct(), and defineNamedArgs().

G4double BLCMDrfdevice::timeIncrement [private]

Referenced by argChanged(), BLCMDrfdevice(), defineNamedArgs(), RFdeviceField::show1step(), and RFdeviceField::UserSteppingAction().

G4String BLCMDrfdevice::fieldMapFile [private]

Referenced by BLCMDrfdevice(), command(), and defineNamedArgs().

G4double BLCMDrfdevice::timeOffset [private]

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

G4String BLCMDrfdevice::autoTimingMethod [private]

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

G4double BLCMDrfdevice::autoTimingFixP [private]

Referenced by argChanged(), BLCMDrfdevice(), defineNamedArgs(), RFdeviceField::show1step(), and RFdeviceField::UserSteppingAction().

G4double BLCMDrfdevice::autoTimingFixDE [private]

Referenced by argChanged(), BLCMDrfdevice(), defineNamedArgs(), RFdeviceField::show1step(), and RFdeviceField::UserSteppingAction().

G4double BLCMDrfdevice::autoTimingFixDT [private]

Referenced by argChanged(), BLCMDrfdevice(), defineNamedArgs(), RFdeviceField::show1step(), and RFdeviceField::UserSteppingAction().

G4double BLCMDrfdevice::autoTimingFixXdeflection [private]

Referenced by argChanged(), BLCMDrfdevice(), defineNamedArgs(), RFdeviceField::show1step(), and RFdeviceField::UserSteppingAction().

G4double BLCMDrfdevice::autoTimingFixYdeflection [private]

Referenced by argChanged(), BLCMDrfdevice(), defineNamedArgs(), RFdeviceField::show1step(), and RFdeviceField::UserSteppingAction().

G4double BLCMDrfdevice::autoTimingFailureLimit [private]

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

G4double BLCMDrfdevice::autoTimingZlocal [private]

Referenced by argChanged(), BLCMDrfdevice(), construct(), defineNamedArgs(), and RFdeviceField::show1step().

G4int BLCMDrfdevice::verbose [private]

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

G4int BLCMDrfdevice::kill [private]

Referenced by BLCMDrfdevice(), construct(), and defineNamedArgs().

AutoTimingState BLCMDrfdevice::state [private]

Referenced by argChanged(), BLCMDrfdevice(), command(), and RFdeviceField::UserSteppingAction().

G4int BLCMDrfdevice::whatFixed [private]

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

AutoTimingWhatToAdjust BLCMDrfdevice::what2adjust [private]

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

G4double BLCMDrfdevice::LtimingVolume [private]

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

G4double BLCMDrfdevice::overallLength [private]

Referenced by argChanged(), BLCMDrfdevice(), generatePoints(), getLength(), and isOutside().

G4double BLCMDrfdevice::outerRadius [private]

Referenced by argChanged(), BLCMDrfdevice(), generatePoints(), getHeight(), getWidth(), and isOutside().

G4double BLCMDrfdevice::omega [private]

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

G4double BLCMDrfdevice::rFactor [private]

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

G4double BLCMDrfdevice::E2Bfactor [private]

Referenced by RFdeviceField::addFieldValue(), argChanged(), BLCMDrfdevice(), and command().

BLFieldMap* BLCMDrfdevice::fieldMap [private]

Referenced by BLCMDrfdevice(), command(), and RFdeviceField::RFdeviceField().

std::vector<RFdeviceField *> BLCMDrfdevice::rfdeviceField [private]

Referenced by construct(), and isOK().

int BLCMDrfdevice::changeCount [private]

Referenced by argChanged(), and BLCMDrfdevice().

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

BLCMDrfdevice.cc


Public Member Functions
	BLCMDrfdevice ()
	Default constructor. Defines the command, etc.
virtual	~BLCMDrfdevice ()
	Destructor.
	BLCMDrfdevice (const BLCMDrfdevice &r)
	Copy constructor.
BLElement *	clone ()
	clone()
G4String	commandName ()
	commandName() returns "rfdevice".
int	command (BLArgumentVector &argv, BLArgumentMap &namedArgs)
	command() implements the rfdevice command.
void	defineNamedArgs ()
	defineNamedArgs() defines the named arguments of the command.
void	argChanged ()
	argChanged() does internal computations after some arg changed
void	construct (G4RotationMatrix relativeRotation, G4ThreeVector relativePosition, G4LogicalVolume parent, G4String parentName, G4RotationMatrix *parentRotation, G4ThreeVector parentPosition)
	construct() - construct the rfdevice. Creates a new RFdeviceField and adds it to BLGlobalField.
G4double	getLength ()
	getLength() returns the overallLength of the rfdevice
G4double	getWidth ()
	getWidth() returns the outer radius of the rfdevice
G4double	getHeight ()
	getHeight() returns the outer radius of the rfdevice
G4bool	isOK ()
	isOK() returns true only if all placed rfdevices of this type have had their timing set, and if the tuning (if used) converged.
G4bool	trackOfInterest ()
	trackOfInterest() returns true only if rfdevice timing just completed
void	generatePoints (int npoints, std::vector< G4ThreeVector > &v)
	generatePoints() from BLElement
G4bool	isOutside (G4ThreeVector &local, G4double tolerance)
	isOutside() from BLElement
Private Attributes
G4double	maxGradient
G4double	phaseAcc
G4String	color
G4double	frequency
G4double	innerLength
G4double	innerRadius
G4double	pipeThick
G4double	wallThick
G4String	wallMat
G4double	irisRadius
G4double	collarRadialThick
G4double	collarThick
G4double	win1Thick
G4double	win1OuterRadius
G4double	win2Thick
G4String	winMat
G4double	skinDepth
G4double	timingTolerance
G4double	maxStep
G4String	cavityMaterial
G4double	timeIncrement
G4String	fieldMapFile
G4double	timeOffset
G4String	autoTimingMethod
G4double	autoTimingFixP
G4double	autoTimingFixDE
G4double	autoTimingFixDT
G4double	autoTimingFixXdeflection
G4double	autoTimingFixYdeflection
G4double	autoTimingFailureLimit
G4double	autoTimingZlocal
G4int	verbose
G4int	kill
AutoTimingState	state
G4int	whatFixed
AutoTimingWhatToAdjust	what2adjust
G4double	LtimingVolume
G4double	overallLength
G4double	outerRadius
G4double	omega
G4double	rFactor
G4double	E2Bfactor
BLFieldMap *	fieldMap
std::vector< RFdeviceField * >	rfdeviceField
int	changeCount
Friends
class	RFdeviceField