ExExChProcessChanneling Class Reference

#include <ExExChProcessChanneling.hh>

Inheritance diagram for ExExChProcessChanneling:

Collaboration diagram for ExExChProcessChanneling:

Public Member Functions
	ExExChProcessChanneling (const G4String &processName="ExExChProcessChanneling")
virtual	~ExExChProcessChanneling ()
virtual G4VParticleChange *	PostStepDoIt (const G4Track &, const G4Step &)
virtual G4bool	IsApplicable (const G4ParticleDefinition &)
virtual void	BuildPhysicsTable (const G4ParticleDefinition &)
XVCrystalCharacteristic *	GetPotential ()
void	SetPotential (XVCrystalCharacteristic *)
XVCrystalCharacteristic *	GetElectricField ()
void	SetElectricField (XVCrystalCharacteristic *)
XCrystalIntegratedDensityHub *	GetIntegratedDensity ()
void	SetIntegratedDensity (XCrystalIntegratedDensityHub *)
XVCrystalCharacteristic *	GetNucleiDensity ()
void	SetNucleiDensity (XVCrystalCharacteristic *)
XVCrystalCharacteristic *	GetElectronDensity ()
void	SetElectronDensity (XVCrystalCharacteristic *)
G4double	GetTransverseVariationMax ()
void	SetTransverseVariationMax (G4double aDouble)
G4double	GetTimeStepMin ()
void	SetTimeStepMin (G4double aDouble)
void	ReadFromFileCharacteristics (G4bool)
void	SetFileCharacteristicsName (const G4String &vFilename)
G4bool	GetFileCharacteristicsName ()
Public Member Functions inherited from G4VDiscreteProcess
	G4VDiscreteProcess (const G4String &, G4ProcessType aType=fNotDefined)
	G4VDiscreteProcess (G4VDiscreteProcess &)
virtual	~G4VDiscreteProcess ()
virtual G4double	PostStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &, G4double, G4double, G4double &, G4GPILSelection *)
virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)
virtual G4VParticleChange *	AtRestDoIt (const G4Track &, const G4Step &)
virtual G4VParticleChange *	AlongStepDoIt (const G4Track &, const G4Step &)
Public Member Functions inherited from G4VProcess
	G4VProcess (const G4String &aName="NoName", G4ProcessType aType=fNotDefined)
	G4VProcess (const G4VProcess &right)
virtual	~G4VProcess ()
G4int	operator== (const G4VProcess &right) const
G4int	operator!= (const G4VProcess &right) const
G4double	GetCurrentInteractionLength () const
void	SetPILfactor (G4double value)
G4double	GetPILfactor () const
G4double	AlongStepGPIL (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)
G4double	AtRestGPIL (const G4Track &track, G4ForceCondition *condition)
G4double	PostStepGPIL (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
virtual void	PreparePhysicsTable (const G4ParticleDefinition &)
virtual G4bool	StorePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)
virtual G4bool	RetrievePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)
const G4String &	GetPhysicsTableFileName (const G4ParticleDefinition *, const G4String &directory, const G4String &tableName, G4bool ascii=false)
const G4String &	GetProcessName () const
G4ProcessType	GetProcessType () const
void	SetProcessType (G4ProcessType)
G4int	GetProcessSubType () const
void	SetProcessSubType (G4int)
virtual void	StartTracking (G4Track *)
virtual void	EndTracking ()
virtual void	SetProcessManager (const G4ProcessManager *)
virtual const G4ProcessManager *	GetProcessManager ()
virtual void	ResetNumberOfInteractionLengthLeft ()
G4double	GetNumberOfInteractionLengthLeft () const
G4double	GetTotalNumberOfInteractionLengthTraversed () const
G4bool	isAtRestDoItIsEnabled () const
G4bool	isAlongStepDoItIsEnabled () const
G4bool	isPostStepDoItIsEnabled () const
virtual void	DumpInfo () const
void	SetVerboseLevel (G4int value)
G4int	GetVerboseLevel () const
virtual void	SetMasterProcess (G4VProcess *masterP)
const G4VProcess *	GetMasterProcess () const
virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &part)
virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &)

Protected Member Functions
virtual G4double	GetMeanFreePath (const G4Track &, G4double, G4ForceCondition *)
Protected Member Functions inherited from G4VProcess
void	SubtractNumberOfInteractionLengthLeft (G4double previousStepSize)
void	ClearNumberOfInteractionLengthLeft ()

Private Member Functions
G4double	GetChannelingMeanFreePath (const G4Track &)
void	UpdateParameters (const G4Track &)
G4bool	UpdateInitialParameters (const G4Track &)
void	ResetDensity (const G4Track &)
G4double	ComputeCriticalEnergyBent (const G4Track &)
G4double	ComputeCriticalEnergyMinimumBent (const G4Track &)
G4double	ComputePotentialEnergyBent (const G4Track &)
G4ThreeVector	ComputeTransverseEnergyBent (const G4Track &)
G4ThreeVector	ComputePositionInTheCrystal (G4StepPoint *, const G4Track &)
G4StepPoint *	CheckStepPointLatticeForVolume (G4StepPoint *, const G4Track &)
G4StepPoint *	CheckStepPointLatticeForPosition (G4StepPoint *, const G4Track &)
G4ThreeVector	ComputeTransverseEnergy (const G4Track &)
G4ThreeVector	ComputeKineticEnergy (const G4Track &)
G4ThreeVector	ComputePotentialEnergy (const G4Track &)
G4ThreeVector	ComputeMomentum (const G4Track &, G4StepPoint *)
G4ThreeVector	ComputeCentrifugalEnergy (const G4Track &, G4ThreeVector)
G4ThreeVector	ComputeCentrifugalEnergyMaximumVariation (const G4Track &)
G4double	ComputeCriticalEnergyMaximum (const G4Track &)
G4double	ComputeCriticalEnergyMinimum (const G4Track &)
G4double	ComputeCriticalAngle (const G4Track &)
G4double	ComputeCriticalRadius (const G4Track &)
G4double	ComputeOscillationPeriod (const G4Track &)
G4ThreeVector	ComputePotentialWellCentre (const G4Track &)
G4bool	HasLattice (const G4Track &)
G4bool	HasLatticeOnBoundary (const G4Track &)
G4bool	HasLatticeOnBoundaryPre (const G4Track &)
G4bool	HasLatticeOnBoundaryPost (const G4Track &)
G4bool	ParticleIsNegative (const G4Track &)
G4bool	ParticleIsNotOnBoundaryPre (const G4Track &)
G4bool	ParticleIsNotOnBoundaryPost (const G4Track &)
G4bool	ParticleIsNotOnBoundary (const G4Track &)
void	ComputeCrystalCharacteristic (const G4Track &)
XPhysicalLattice *	GetXPL (const G4Track &)
G4VPhysicalVolume *	GetVolume (const G4Track &)
ExExChParticleUserInfo *	GetInfo (const G4Track &)
G4ParticleDefinition *	GetParticleDefinition (const G4Track &aTrack)
	ExExChProcessChanneling (ExExChProcessChanneling &)
ExExChProcessChanneling &	operator= (const ExExChProcessChanneling &right)
G4bool	UpdateIntegrationStep (const G4Track &, G4ThreeVector &)

Private Attributes
XLatticeManager3 *	fLatticeManager
XVCrystalCharacteristic *	fPotentialEnergy
XVCrystalCharacteristic *	fElectricField
XCrystalIntegratedDensityHub *	fIntegratedDensity
XVCrystalCharacteristic *	fNucleiDensity
XVCrystalCharacteristic *	fElectronDensity
G4String	fFileCharacteristicsName
G4double	fTimeStep
G4double	fTimeStepMin
G4double	fTimeStepMax
G4double	fTimeStepTotal
G4bool	bHasToComputeTrajectory
G4double	bPointYPost
G4double	bPointYPre
G4double	fTransverseVariationMax
G4double	fIntegrationPeriod

Additional Inherited Members
Static Public Member Functions inherited from G4VProcess
static const G4String &	GetProcessTypeName (G4ProcessType)
Protected Attributes inherited from G4VProcess
const G4ProcessManager *	aProcessManager
G4VParticleChange *	pParticleChange
G4ParticleChange	aParticleChange
G4double	theNumberOfInteractionLengthLeft
G4double	currentInteractionLength
G4double	theInitialNumberOfInteractionLength
G4String	theProcessName
G4String	thePhysicsTableFileName
G4ProcessType	theProcessType
G4int	theProcessSubType
G4double	thePILfactor
G4bool	enableAtRestDoIt
G4bool	enableAlongStepDoIt
G4bool	enablePostStepDoIt
G4int	verboseLevel

Detailed Description

Definition at line 43 of file ExExChProcessChanneling.hh.

Constructor & Destructor Documentation

ExExChProcessChanneling() [1/2]

ExExChProcessChanneling::ExExChProcessChanneling

(

const G4String &

processName = "ExExChProcessChanneling"

)

Definition at line 59 of file ExExChProcessChanneling.cc.

                                              :
G4VDiscreteProcess(aName){
    fLatticeManager = XLatticeManager3::GetXLatticeManager();
    
    G4double kCarTolerance =
        G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
    G4cout<<"\n ExExChProcessChanneling::Constructor:";
    G4cout<<"Geometry surface tolerance is: ";
    G4cout<< kCarTolerance / mm << " mm"<<G4endl;
    if(verboseLevel>1) {
        G4cout << GetProcessName() << " is created "<< G4endl;
    }
    
    fFileCharacteristicsName = "";
    fTimeStepMax = 0.;
    fTimeStepMin = 2.E2 * CLHEP::angstrom;
    fTransverseVariationMax = 2.E-2 * CLHEP::angstrom;

    bPointYPre = -1.;
    bPointYPost = -1.;
}

Here is the call graph for this function:

Here is the caller graph for this function:

~ExExChProcessChanneling()

ExExChProcessChanneling::~ExExChProcessChanneling ( )

virtual

Definition at line 83 of file ExExChProcessChanneling.cc.

                                                 {
}

Here is the call graph for this function:

ExExChProcessChanneling() [2/2]

ExExChProcessChanneling::ExExChProcessChanneling ( ExExChProcessChanneling &  right )

private

Definition at line 89 of file ExExChProcessChanneling.cc.

                                                       :
G4VDiscreteProcess(right){
    ;
}

Member Function Documentation

BuildPhysicsTable()

void ExExChProcessChanneling::BuildPhysicsTable ( const G4ParticleDefinition &  )

virtual

Reimplemented from G4VProcess.

Definition at line 849 of file ExExChProcessChanneling.cc.

                                              {
    
}

Here is the call graph for this function:

Here is the caller graph for this function:

CheckStepPointLatticeForPosition()

G4StepPoint * ExExChProcessChanneling::CheckStepPointLatticeForPosition ( G4StepPoint *  vStep, const G4Track &  aTrack  )

private

Definition at line 405 of file ExExChProcessChanneling.cc.

                                                                           {
    
    G4StepPoint* vStepPre = aTrack.GetStep()->GetPreStepPoint();
    G4StepPoint* vStepPost = aTrack.GetStep()->GetPostStepPoint();
    
    if( fLatticeManager->HasLattice(vStep->GetPhysicalVolume()) ) {
        return vStep;
    }
    else if(fLatticeManager->HasLattice(vStepPost->GetPhysicalVolume())
            == false &&
            fLatticeManager->HasLattice(vStepPre->GetPhysicalVolume())
            == true &&
            vStep == vStepPost &&
            vStepPost->GetStepStatus() == fGeomBoundary) {
        return vStepPost;
    }
    else if(fLatticeManager->HasLattice(vStepPre->GetPhysicalVolume())
            == false &&
            fLatticeManager->HasLattice(vStepPost->GetPhysicalVolume())
            == true &&
            vStep == vStepPre &&
            vStepPre->GetStepStatus() == fGeomBoundary) {
        return vStepPre;
    }
    else{
        return vStep;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

CheckStepPointLatticeForVolume()

G4StepPoint * ExExChProcessChanneling::CheckStepPointLatticeForVolume ( G4StepPoint *  vStep, const G4Track &  aTrack  )

private

Definition at line 373 of file ExExChProcessChanneling.cc.

                                                                         {
    
    G4StepPoint* vStepPre = aTrack.GetStep()->GetPreStepPoint();
    G4StepPoint* vStepPost = aTrack.GetStep()->GetPostStepPoint();
    
    if( fLatticeManager->HasLattice(vStep->GetPhysicalVolume()) ) {
        return vStep;
    }
    else if(fLatticeManager->HasLattice(vStepPost->GetPhysicalVolume())
            == false
            && fLatticeManager->HasLattice(vStepPre->GetPhysicalVolume())
            == true
            && vStep == vStepPost &&
            vStepPost->GetStepStatus() == fGeomBoundary) {
        return vStepPre;
    }
    else if(fLatticeManager->HasLattice(vStepPre->GetPhysicalVolume())
            == false &&
            fLatticeManager->HasLattice(vStepPost->GetPhysicalVolume())
            == true &&
            vStep == vStepPre &&
            vStepPre->GetStepStatus() == fGeomBoundary) {
        return vStepPost;
    }
    else{
        return vStep;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeCentrifugalEnergy()

G4ThreeVector ExExChProcessChanneling::ComputeCentrifugalEnergy ( const G4Track &  aTrack, G4ThreeVector  vPosition  )

private

Definition at line 626 of file ExExChProcessChanneling.cc.

                                                                       {
    //----------------------------------------
    // compute the transverse energy variation
    // in the crystal reference system
    //----------------------------------------
    
    G4double vTotalEnergy =
        aTrack.GetStep()->GetPreStepPoint()->GetTotalEnergy();
    
    G4double vPositionX = vPosition.x();
    
    if(ParticleIsNegative(aTrack) && false){
        vPositionX -=
        GetXPL(aTrack)->ComputeInterplanarPeriod() * 0.5;
    }
    G4ThreeVector vEnergyVariation = G4ThreeVector();;
    if(GetXPL(aTrack)->IsBent()){ 
    vEnergyVariation =
        G4ThreeVector(vTotalEnergy * vPositionX /
                      GetXPL(aTrack)->GetCurvatureRadius().x(),
                      0.,
                      0.);
    }
    
    return vEnergyVariation;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeCentrifugalEnergyMaximumVariation()

G4ThreeVector ExExChProcessChanneling::ComputeCentrifugalEnergyMaximumVariation ( const G4Track &  aTrack )

private

Definition at line 675 of file ExExChProcessChanneling.cc.

                                                               {
    //----------------------------------------
    // compute the transverse energy variation
    // in the crystal reference system
    //----------------------------------------
    
    G4double vTotalEnergy =
        aTrack.GetStep()->GetPreStepPoint()->GetTotalEnergy();
    
    G4ThreeVector vEnergyVariation = G4ThreeVector();
    if(GetXPL(aTrack)->IsBent()){
    vEnergyVariation = G4ThreeVector(vTotalEnergy *
                    GetXPL(aTrack)->ComputeInterplanarPeriod() /
                    GetXPL(aTrack)->GetCurvatureRadius().x(),
                    0.,
                    0.);
    }
    
    return vEnergyVariation;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeCriticalAngle()

G4double ExExChProcessChanneling::ComputeCriticalAngle ( const G4Track &  aTrack )

private

Definition at line 752 of file ExExChProcessChanneling.cc.

                                           {
    //----------------------------------------
    // compute the critical angle
    // for chenneling
    //----------------------------------------
    
    G4double vTotalEnergy =
        aTrack.GetStep()->GetPostStepPoint()->GetTotalEnergy();
    G4double vCriticalAngle = std::pow( 2.0 *
                    std::fabs( ( ComputeCriticalEnergyMaximum(aTrack)
                           - ComputeCriticalEnergyMinimum(aTrack) )
                           / vTotalEnergy ) , 0.5);
    return vCriticalAngle;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeCriticalEnergyBent()

G4double ExExChProcessChanneling::ComputeCriticalEnergyBent ( const G4Track &  )

private

Here is the caller graph for this function:

ComputeCriticalEnergyMaximum()

G4double ExExChProcessChanneling::ComputeCriticalEnergyMaximum ( const G4Track &  aTrack )

private

Definition at line 702 of file ExExChProcessChanneling.cc.

                                                   {
    //----------------------------------------
    // compute the critical energy
    // for channeling
    //----------------------------------------
    
    G4double vCriticalEnergy = 0.;
    
    if(ParticleIsNegative(aTrack)){
        vCriticalEnergy =
            - fPotentialEnergy->GetMinimum(GetXPL(aTrack));
    }
    else{
        vCriticalEnergy =
            + fPotentialEnergy->GetMaximum(GetXPL(aTrack));
    }
    
    vCriticalEnergy *= std::fabs(GetParticleDefinition(aTrack)->GetPDGCharge());
    
    return vCriticalEnergy;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeCriticalEnergyMinimum()

G4double ExExChProcessChanneling::ComputeCriticalEnergyMinimum ( const G4Track &  aTrack )

private

Definition at line 727 of file ExExChProcessChanneling.cc.

                                                   {
    //----------------------------------------
    // compute the critical energy minimum
    // for channeling
    //----------------------------------------
    
    G4double vCriticalEnergy = 0.;
    
    if(ParticleIsNegative(aTrack)){
        vCriticalEnergy =
            - fPotentialEnergy->GetMaximum(GetXPL(aTrack));
    }
    else{
        vCriticalEnergy =
            + fPotentialEnergy->GetMinimum(GetXPL(aTrack));
    }
    
    vCriticalEnergy *= std::fabs(GetParticleDefinition(aTrack)->GetPDGCharge());
    
    return vCriticalEnergy;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeCriticalEnergyMinimumBent()

G4double ExExChProcessChanneling::ComputeCriticalEnergyMinimumBent ( const G4Track &  )

private

Here is the caller graph for this function:

ComputeCriticalRadius()

G4double ExExChProcessChanneling::ComputeCriticalRadius ( const G4Track &  aTrack )

private

Definition at line 786 of file ExExChProcessChanneling.cc.

                                            {
    //----------------------------------------
    // compute the critical radius
    // for channeling
    //----------------------------------------
    
    G4double vTotalEnergy =
        aTrack.GetStep()->GetPreStepPoint()->GetTotalEnergy();
    
    G4double vCriticalRadius = 1.E-20;
    if(fElectricField->GetMaximum(GetXPL(aTrack)) != 0.){
        vCriticalRadius = vTotalEnergy 
                        / fElectricField->GetMaximum(GetXPL(aTrack));
    }
    return vCriticalRadius;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeCrystalCharacteristic()

void ExExChProcessChanneling::ComputeCrystalCharacteristic ( const G4Track &  aTrack )

private

Definition at line 994 of file ExExChProcessChanneling.cc.

                                                   {
    fIntegratedDensity->SetXPhysicalLattice(GetXPL(aTrack));
    fIntegratedDensity->InitializeTables();
    
    if(fFileCharacteristicsName != ""){
        G4String filename;
        fElectronDensity->InitializePhysicalLattice(GetXPL(aTrack));
        fNucleiDensity->InitializePhysicalLattice(GetXPL(aTrack));
        fPotentialEnergy->InitializePhysicalLattice(GetXPL(aTrack));
        fElectricField->InitializePhysicalLattice(GetXPL(aTrack));

        filename = fFileCharacteristicsName + "_pot.txt";
        G4cout << filename << G4endl;
        fPotentialEnergy->ReadFromECHARM(filename,CLHEP::eV);
        fPotentialEnergy->PrintOnFile("temppot.dat",GetXPL(aTrack));

        filename = fFileCharacteristicsName + "_efx.txt";
        G4cout << filename << G4endl;
        fElectricField->ReadFromECHARM(filename,CLHEP::eV/CLHEP::m);
        fElectricField->PrintOnFile("tempefx.dat",GetXPL(aTrack));

        filename = fFileCharacteristicsName + "_atd.txt";
        G4cout << filename << G4endl;
        fNucleiDensity->ReadFromECHARM(filename);

        filename = fFileCharacteristicsName + "_eld.txt";
        G4cout << filename << G4endl;
        fElectronDensity->ReadFromECHARM(filename);
        fIntegratedDensity->ReadFromFiles(fFileCharacteristicsName);
    }
    else{
        fPotentialEnergy->InitializePhysicalLattice(
                                                GetXPL(aTrack));
        fElectricField->InitializePhysicalLattice(GetXPL(aTrack));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeKineticEnergy()

G4ThreeVector ExExChProcessChanneling::ComputeKineticEnergy ( const G4Track &  aTrack )

private

Definition at line 585 of file ExExChProcessChanneling.cc.

                                           {
    //----------------------------------------
    // compute the particle kinetic energy
    // in the crystal reference system
    //----------------------------------------
    
    G4double vTotalEnergy =
        aTrack.GetStep()->GetPostStepPoint()->GetTotalEnergy();
    
    G4ThreeVector vMom = GetInfo(aTrack)->GetMomentumChanneled();
    
    G4ThreeVector vKineticEnergy = 0.5 *
        G4ThreeVector((vMom.x() * vMom.x()) / vTotalEnergy,
                      0.,
                      (vMom.z() * vMom.z())  / vTotalEnergy);
    
    return vKineticEnergy;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeMomentum()

G4ThreeVector ExExChProcessChanneling::ComputeMomentum ( const G4Track &  aTrack, G4StepPoint *  vStep  )

private

Definition at line 656 of file ExExChProcessChanneling.cc.

                                                         {
    //----------------------------------------
    // compute the particle momentum
    // in the crystal reference system
    //----------------------------------------
    
    G4ThreeVector vPosition = ComputePositionInTheCrystal(vStep,aTrack);
    
    G4ThreeVector vMomentum = aTrack.GetMomentum();

    GetXPL(aTrack)->
    ProjectMomentumVectorFromWorldToLattice(vMomentum,vPosition);

    return vMomentum;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeOscillationPeriod()

G4double ExExChProcessChanneling::ComputeOscillationPeriod ( const G4Track &  aTrack )

private

Definition at line 770 of file ExExChProcessChanneling.cc.

                                               {
    //----------------------------------------
    // compute the particle oscillation
    // period in the crystal channel
    //----------------------------------------
    
    G4double vInterplanarPeriod =
        GetXPL(aTrack)->ComputeInterplanarPeriod();
    G4double vOscillationPeriod =
        CLHEP::pi * vInterplanarPeriod / ComputeCriticalAngle(aTrack);
    return vOscillationPeriod;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ComputePositionInTheCrystal()

G4ThreeVector ExExChProcessChanneling::ComputePositionInTheCrystal ( G4StepPoint *  vStep, const G4Track &  aTrack  )

private

Definition at line 341 of file ExExChProcessChanneling.cc.

                                                                     {
    
    G4StepPoint* vStepVol = CheckStepPointLatticeForVolume(vStep,aTrack);
    G4StepPoint* vStepPos = CheckStepPointLatticeForPosition(vStep,aTrack);
    
    G4TouchableHistory* theTouchable =
        (G4TouchableHistory*)(vStepVol->GetTouchable());
    G4ThreeVector vWorldPos = vStepPos->GetPosition();
    G4ThreeVector vLocalPos =
        theTouchable->GetHistory()->GetTopTransform().TransformPoint(vWorldPos);
    
    
    if(GetXPL(aTrack)->IsBent() == false){
        G4Box* vXtalSolid =
            (G4Box*) vStepVol->GetPhysicalVolume()
            ->GetLogicalVolume()->GetSolid();
        vLocalPos += G4ThreeVector(vXtalSolid->GetXHalfLength(),
                                   vXtalSolid->GetYHalfLength(),
                                   vXtalSolid->GetZHalfLength());
    }
    else{
        G4Tubs* vXtalSolid =
            (G4Tubs*) vStepVol->GetPhysicalVolume()
            ->GetLogicalVolume()->GetSolid();
        vLocalPos.rotateZ(-vXtalSolid->GetStartPhiAngle());
    }
    return vLocalPos;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ComputePotentialEnergy()

G4ThreeVector ExExChProcessChanneling::ComputePotentialEnergy ( const G4Track &  aTrack )

private

Definition at line 607 of file ExExChProcessChanneling.cc.

                                             {
    //----------------------------------------
    // compute the particle transverse energy
    // in the crystal reference system
    //----------------------------------------
    
    
    G4ThreeVector vPotentialEnergy =
        fPotentialEnergy->GetEC(GetInfo(aTrack)->GetPositionChanneled(),
                                GetXPL(aTrack));
    
    vPotentialEnergy *= GetParticleDefinition(aTrack)->GetPDGCharge();
    
    return vPotentialEnergy;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ComputePotentialEnergyBent()

G4double ExExChProcessChanneling::ComputePotentialEnergyBent ( const G4Track &  )

private

Here is the caller graph for this function:

ComputePotentialWellCentre()

G4ThreeVector ExExChProcessChanneling::ComputePotentialWellCentre ( const G4Track &  aTrack )

private

Definition at line 805 of file ExExChProcessChanneling.cc.

                                                 {
    //----------------------------------------
    // compute the central point of
    // the potential well for channeling
    //----------------------------------------
    
    G4double vInterplanarPeriodHalf =
        0.5 * GetXPL(aTrack)->ComputeInterplanarPeriod();
    
    G4double vCentreX = vInterplanarPeriodHalf;
    
    if(GetXPL(aTrack)->IsBent()){
        G4double vTotalEnergy =
            aTrack.GetStep()->GetPreStepPoint()->GetTotalEnergy();
        
        G4double vPotentialWellDepth =
            ComputeCriticalEnergyMaximum(aTrack)
            - (ComputeCriticalEnergyMinimum(aTrack));
        
        vCentreX *= (1. - 0.5 * vTotalEnergy /
                     vPotentialWellDepth /
                     GetXPL(aTrack)->GetCurvatureRadius().x() *
                     vInterplanarPeriodHalf );
    }
    
    G4ThreeVector vCentre = G4ThreeVector(vCentreX,0.,0.);
    
    
    return vCentre;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeTransverseEnergy()

G4ThreeVector ExExChProcessChanneling::ComputeTransverseEnergy ( const G4Track &  aTrack )

private

Definition at line 572 of file ExExChProcessChanneling.cc.

                                              {
    //----------------------------------------
    // compute the particle transverse energy
    // in the crystal reference system
    //----------------------------------------
    
    G4ThreeVector vTransverseEnergy = ComputePotentialEnergy(aTrack)
        + ComputeKineticEnergy(aTrack);
    return vTransverseEnergy;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeTransverseEnergyBent()

G4ThreeVector ExExChProcessChanneling::ComputeTransverseEnergyBent ( const G4Track &  )

private

Here is the caller graph for this function:

GetChannelingMeanFreePath()

G4double ExExChProcessChanneling::GetChannelingMeanFreePath ( const G4Track &  aTrack )

private

Definition at line 475 of file ExExChProcessChanneling.cc.

                                                {
    //----------------------------------------
    // return the channeling MFP
    //----------------------------------------
    
    
    G4double vMFP = 0.1 * ComputeOscillationPeriod(aTrack);
    
    if(HasLatticeOnBoundaryPre(aTrack) == true){
        vMFP = 0.001 * ComputeOscillationPeriod(aTrack);
    }
    
    return vMFP;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetElectricField()

XVCrystalCharacteristic * ExExChProcessChanneling::GetElectricField

(

)

Definition at line 109 of file ExExChProcessChanneling.cc.

                                                                  {
    return fElectricField;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetElectronDensity()

XVCrystalCharacteristic * ExExChProcessChanneling::GetElectronDensity

(

)

Definition at line 149 of file ExExChProcessChanneling.cc.

                                                                    {
    return fElectronDensity;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetFileCharacteristicsName()

G4bool ExExChProcessChanneling::GetFileCharacteristicsName ( )

inline

Definition at line 99 of file ExExChProcessChanneling.hh.

{return fFileCharacteristicsName;};

Here is the call graph for this function:

GetInfo()

ExExChParticleUserInfo * ExExChProcessChanneling::GetInfo ( const G4Track &  aTrack )

private

Definition at line 980 of file ExExChProcessChanneling.cc.

                              {
    return (ExExChParticleUserInfo*) aTrack.GetUserInformation();
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetIntegratedDensity()

XCrystalIntegratedDensityHub * ExExChProcessChanneling::GetIntegratedDensity

(

)

Definition at line 123 of file ExExChProcessChanneling.cc.

                      {
    return fIntegratedDensity;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetMeanFreePath()

G4double ExExChProcessChanneling::GetMeanFreePath ( const G4Track &  aTrack, G4double  , G4ForceCondition *  condition  )

protectedvirtual

Implements G4VDiscreteProcess.

Definition at line 493 of file ExExChProcessChanneling.cc.

                                            {
    
    //----------------------------------------
    // the condition is forced to check if
    // the volume has a lattice at each step.
    // if it hasn't, return DBL_MAX
    //----------------------------------------
    
    *condition = Forced;
    
    if(HasLattice(aTrack)){
        GetInfo(aTrack)->SetInTheCrystal(true);
        return GetChannelingMeanFreePath(aTrack);
    }
    else{
        GetInfo(aTrack)->SetInTheCrystal(false);
        return DBL_MAX;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetNucleiDensity()

XVCrystalCharacteristic * ExExChProcessChanneling::GetNucleiDensity

(

)

Definition at line 136 of file ExExChProcessChanneling.cc.

                                                                  {
    return fNucleiDensity;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetParticleDefinition()

G4ParticleDefinition * ExExChProcessChanneling::GetParticleDefinition ( const G4Track &  aTrack )

private

Definition at line 987 of file ExExChProcessChanneling.cc.

                                            {
    return const_cast<G4ParticleDefinition*>(aTrack.GetParticleDefinition());
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetPotential()

XVCrystalCharacteristic * ExExChProcessChanneling::GetPotential

(

)

Definition at line 96 of file ExExChProcessChanneling.cc.

                                                              {
    return fPotentialEnergy;
}

Here is the call graph for this function:

GetTimeStepMin()

G4double ExExChProcessChanneling::GetTimeStepMin ( )

inline

Definition at line 92 of file ExExChProcessChanneling.hh.

{return fTimeStepMin;};

GetTransverseVariationMax()

G4double ExExChProcessChanneling::GetTransverseVariationMax ( )

inline

Definition at line 84 of file ExExChProcessChanneling.hh.

                                        {
        return fTransverseVariationMax;
        };

GetVolume()

G4VPhysicalVolume* ExExChProcessChanneling::GetVolume ( const G4Track &  )

private

Here is the caller graph for this function:

GetXPL()

XPhysicalLattice * ExExChProcessChanneling::GetXPL ( const G4Track &  aTrack )

private

Definition at line 856 of file ExExChProcessChanneling.cc.

                             {
    if(fLatticeManager->HasLattice(
                aTrack.GetStep()->GetPostStepPoint()->GetPhysicalVolume())){
        return fLatticeManager->GetXPhysicalLattice(aTrack.GetStep()
                            ->GetPostStepPoint()->GetPhysicalVolume());
    }
    else if(fLatticeManager->HasLattice(aTrack.GetStep()->GetPreStepPoint()
                    ->GetPhysicalVolume()) &&
            aTrack.GetStep()->GetPostStepPoint()->GetStepStatus()
            == fGeomBoundary) {
        return fLatticeManager->GetXPhysicalLattice(aTrack.GetStep()
                    ->GetPreStepPoint()->GetPhysicalVolume());
    }
    else{
        G4cout << "LATTICE NOT FOUND: ERROR" << G4endl;
        return NULL;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

HasLattice()

G4bool ExExChProcessChanneling::HasLattice ( const G4Track &  aTrack )

private

Definition at line 877 of file ExExChProcessChanneling.cc.

                                                               {
    if(fLatticeManager->HasLattice(aTrack.GetStep()
                    ->GetPostStepPoint()->GetPhysicalVolume())){
        return true;
    }
    else{
        return false;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

HasLatticeOnBoundary()

G4bool ExExChProcessChanneling::HasLatticeOnBoundary ( const G4Track &  aTrack )

private

Definition at line 890 of file ExExChProcessChanneling.cc.

                                           {
    if(HasLatticeOnBoundaryPost(aTrack) || HasLatticeOnBoundaryPre(aTrack)) {
        return true;
    }
    else{
        return false;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

HasLatticeOnBoundaryPost()

G4bool ExExChProcessChanneling::HasLatticeOnBoundaryPost ( const G4Track &  aTrack )

private

Definition at line 916 of file ExExChProcessChanneling.cc.

                                               {
    if(fLatticeManager->HasLattice(aTrack.GetStep()->
                    GetPostStepPoint()->GetPhysicalVolume()) &&
       aTrack.GetStep()->GetPostStepPoint()->GetStepStatus() == fGeomBoundary) {
        return true;
    }
    else{
        return false;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

HasLatticeOnBoundaryPre()

G4bool ExExChProcessChanneling::HasLatticeOnBoundaryPre ( const G4Track &  aTrack )

private

Definition at line 902 of file ExExChProcessChanneling.cc.

                                              {
    if(fLatticeManager->HasLattice(aTrack.GetStep()->GetPreStepPoint()->
                GetPhysicalVolume()) &&
       aTrack.GetStep()->GetPreStepPoint()->GetStepStatus() == fGeomBoundary) {
        return true;
    }
    else{
        return false;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

IsApplicable()

G4bool ExExChProcessChanneling::IsApplicable ( const G4ParticleDefinition &  aPD )

virtual

Reimplemented from G4VProcess.

Definition at line 842 of file ExExChProcessChanneling.cc.

                                             {
    return(aPD.GetPDGCharge() != 0.);
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

ExExChProcessChanneling& ExExChProcessChanneling::operator= ( const ExExChProcessChanneling &  right )

private

Here is the caller graph for this function:

ParticleIsNegative()

G4bool ExExChProcessChanneling::ParticleIsNegative ( const G4Track &  aTrack )

private

Definition at line 929 of file ExExChProcessChanneling.cc.

                                                                       {
    if(GetParticleDefinition(aTrack)->GetPDGCharge() < 0.) {
        return true;
    }
    else{
        return false;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ParticleIsNotOnBoundary()

G4bool ExExChProcessChanneling::ParticleIsNotOnBoundary ( const G4Track &  aTrack )

private

Definition at line 967 of file ExExChProcessChanneling.cc.

                                              {
    if(ParticleIsNotOnBoundaryPost(aTrack) ||
       ParticleIsNotOnBoundaryPre(aTrack)){
        return true;
    }
    else{
        return false;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ParticleIsNotOnBoundaryPost()

G4bool ExExChProcessChanneling::ParticleIsNotOnBoundaryPost ( const G4Track &  aTrack )

private

Definition at line 955 of file ExExChProcessChanneling.cc.

                                                  {
    if(aTrack.GetStep()->GetPostStepPoint()->GetStepStatus() != fGeomBoundary){
        return true;
    }
    else{
        return false;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ParticleIsNotOnBoundaryPre()

G4bool ExExChProcessChanneling::ParticleIsNotOnBoundaryPre ( const G4Track &  aTrack )

private

Definition at line 943 of file ExExChProcessChanneling.cc.

                                                 {
    if(aTrack.GetStep()->GetPreStepPoint()->GetStepStatus() != fGeomBoundary){
        return true;
    }
    else{
        return false;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

PostStepDoIt()

G4VParticleChange * ExExChProcessChanneling::PostStepDoIt ( const G4Track &  aTrack, const G4Step &    )

virtual

Reimplemented from G4VDiscreteProcess.

Definition at line 518 of file ExExChProcessChanneling.cc.

                           {
    
    //----------------------------------------
    // check if the volume has a lattice
    // and if the particle is in channeling.
    // If it is so, the particle is forced
    // to follow the channeling plane
    // direction. If the particle has
    // dechanneled or exited the crystal,
    // the outgoing angle is evaluated
    //----------------------------------------
    
    aParticleChange.Initialize(aTrack);
    
    GetInfo(aTrack)->StoreDensityPreviousStep();
    
    if((HasLattice(aTrack) == true) &&
            (HasLatticeOnBoundaryPost(aTrack) == false)){
        UpdateParameters(aTrack);
        
        G4ThreeVector vMomentum = 
                GetInfo(aTrack)->GetMomentumChanneled().unit();

        G4ThreeVector vPosition;
        vPosition =
             ComputePositionInTheCrystal(aTrack.GetStep()->GetPostStepPoint(),
             aTrack);

        GetXPL(aTrack)->ProjectMomentumVectorFromLatticeToWorld(vMomentum,
                                                                vPosition);

        aParticleChange.ProposeMomentumDirection(vMomentum.unit());
    }
    else{
        // if the volume has no lattice it resets the density factors
        ResetDensity(aTrack);
        GetInfo(aTrack)->SetMomentumChanneled(G4ThreeVector(DBL_MAX,
                                                            DBL_MAX,
                                                            DBL_MAX));
                                                            
        GetInfo(aTrack)->SetPositionChanneled(G4ThreeVector(DBL_MAX,
                                                            DBL_MAX,
                                                            DBL_MAX));
    }
    
    return &aParticleChange;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ReadFromFileCharacteristics()

void ExExChProcessChanneling::ReadFromFileCharacteristics

(

G4bool

)

Here is the caller graph for this function:

ResetDensity()

void ExExChProcessChanneling::ResetDensity ( const G4Track &  aTrack )

private

Definition at line 330 of file ExExChProcessChanneling.cc.

                                                               {
    GetInfo(aTrack)->SetNucleiDensity(1.);
    GetInfo(aTrack)->SetElectronDensity(1.);
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetElectricField()

void ExExChProcessChanneling::SetElectricField

(

XVCrystalCharacteristic *

vElectricField

)

Definition at line 116 of file ExExChProcessChanneling.cc.

                                                         {
    fElectricField = vElectricField;
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetElectronDensity()

void ExExChProcessChanneling::SetElectronDensity

(

XVCrystalCharacteristic *

vElectronDensity

)

Definition at line 156 of file ExExChProcessChanneling.cc.

                                                             {
    fElectronDensity = vElectronDensity;
}

Here is the caller graph for this function:

SetFileCharacteristicsName()

void ExExChProcessChanneling::SetFileCharacteristicsName ( const G4String &  vFilename )

inline

Definition at line 97 of file ExExChProcessChanneling.hh.

    {fFileCharacteristicsName = vFilename;};

Here is the caller graph for this function:

SetIntegratedDensity()

void ExExChProcessChanneling::SetIntegratedDensity

(

XCrystalIntegratedDensityHub *

vIntegratedDensity

)

Definition at line 130 of file ExExChProcessChanneling.cc.

                                                                      {
    fIntegratedDensity = vIntegratedDensity;
}

Here is the caller graph for this function:

SetNucleiDensity()

void ExExChProcessChanneling::SetNucleiDensity

(

XVCrystalCharacteristic *

vNucleiDensity

)

Definition at line 143 of file ExExChProcessChanneling.cc.

                                                         {
    fNucleiDensity = vNucleiDensity;
}

Here is the caller graph for this function:

SetPotential()

void ExExChProcessChanneling::SetPotential

(

XVCrystalCharacteristic *

vPotential

)

Definition at line 103 of file ExExChProcessChanneling.cc.

                                                 {
    fPotentialEnergy = vPotential;
}

Here is the caller graph for this function:

SetTimeStepMin()

void ExExChProcessChanneling::SetTimeStepMin ( G4double  aDouble )

inline

Definition at line 93 of file ExExChProcessChanneling.hh.

{fTimeStepMin = aDouble;};

Here is the call graph for this function:

Here is the caller graph for this function:

SetTransverseVariationMax()

void ExExChProcessChanneling::SetTransverseVariationMax ( G4double  aDouble )

inline

Definition at line 88 of file ExExChProcessChanneling.hh.

                                                    {
        fTransverseVariationMax = aDouble;
        };

Here is the caller graph for this function:

UpdateInitialParameters()

G4bool ExExChProcessChanneling::UpdateInitialParameters ( const G4Track &  aTrack )

private

Definition at line 162 of file ExExChProcessChanneling.cc.

                                                                            {
    
    if(GetInfo(aTrack)->GetPositionChanneled().x() == DBL_MAX){
        // when the particle enters the crystal the position in the channel
        //is randomly generated using a uniform distribution
        G4double vXposition = G4UniformRand() *
        GetXPL(aTrack)->ComputeInterplanarPeriod();
        
        //vXposition = 1.0 * CLHEP::angstrom;
    
        //initial position in the channel is stored
        GetInfo(aTrack)->SetPositionChanneled(G4ThreeVector(vXposition,
                                                            0.,
                                                            0.));
        GetInfo(aTrack)->SetPositionChanneledInitial(G4ThreeVector(vXposition,
                                                                   0.,
                                                                   0.));
    }
    
    if(GetInfo(aTrack)->GetMomentumChanneledInitial().x() == DBL_MAX){
        // the first time it enter the crystal we take the momentum
        // for the post step which is the only one in the crystal
        G4ThreeVector vMomentum =
        ComputeMomentum(aTrack,aTrack.GetStep()->GetPostStepPoint());
        
        GetInfo(aTrack)->SetMomentumChanneled(vMomentum);
        GetInfo(aTrack)->SetMomentumChanneledInitial(vMomentum);
        return true;
    }
    
    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateIntegrationStep()

G4bool ExExChProcessChanneling::UpdateIntegrationStep ( const G4Track &  aTrack, G4ThreeVector &  vMom  )

private

Definition at line 437 of file ExExChProcessChanneling.cc.

                                                                {
    
    if(vMom.x() != 0.0 || vMom.y() != 0.0){
        double xy2 = vMom.x() * vMom.x() + vMom.y()*vMom.y();
        
        if(xy2!=0.){
            fTimeStep =
                    std::fabs(fTransverseVariationMax * 
                    aTrack.GetStep()->GetPreStepPoint()->GetTotalEnergy() /
                    std::pow(xy2,0.5));
            if(fTimeStep < fTimeStepMin) fTimeStep = fTimeStepMin;
            else{
                fTimeStepMax = std::sqrt( fTransverseVariationMax *
                aTrack.GetStep()->GetPreStepPoint()->GetTotalEnergy() /
                std::fabs(fElectricField->GetMaximum(GetXPL(aTrack))));
                
                if(fTimeStep > fTimeStepMax) fTimeStep = fTimeStepMax;
            }
        }
        else{
            fTimeStep = fTimeStepMin;
        }
        
        if(fTimeStep + fTimeStepTotal > fIntegrationPeriod){
            fTimeStep = fIntegrationPeriod - fTimeStepTotal;
        }
        
        return true;
    }
    else{
        fTimeStep = fTimeStepMin;
    }
    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateParameters()

void ExExChProcessChanneling::UpdateParameters ( const G4Track &  aTrack )

private

Definition at line 196 of file ExExChProcessChanneling.cc.

                                                                   {
    
    if(fIntegratedDensity->HasBeenInitialized(GetXPL(aTrack))
       == false){
        ComputeCrystalCharacteristic(aTrack);
        G4cout << "ChannelingProcess::UpdatePositionMomentumDensity::";
        G4cout<<"fIntegratedDensity->Initialized" << G4endl;
    }
    
    if(UpdateInitialParameters(aTrack) == false){
        G4ThreeVector vMomentumNew = 
                ComputeMomentum(aTrack,
                                aTrack.GetStep()->GetPreStepPoint());
        GetInfo(aTrack)->SetMomentumChanneled(vMomentumNew);
    }
    G4ThreeVector vPositionPost =
    ComputePositionInTheCrystal(aTrack.GetStep()->GetPostStepPoint(),aTrack);
    G4ThreeVector vPositionPre =
    ComputePositionInTheCrystal(aTrack.GetStep()->GetPreStepPoint(),aTrack);
    
    bHasToComputeTrajectory = true;

    if(vPositionPost.y() == bPointYPost &&
       vPositionPre.y() == bPointYPre){
        bHasToComputeTrajectory = false;
    }
    else{
        if(GetXPL(aTrack)->IsBent()){
                bPointYPre = vPositionPre.y();
                bPointYPost = vPositionPost.y();
        }
        else{
                bPointYPre = vPositionPre.z();
                bPointYPost = vPositionPost.z();
        }
        }

    G4ThreeVector fMom = GetInfo(aTrack)->GetMomentumChanneled();
    G4ThreeVector fPos = GetInfo(aTrack)->GetPositionChanneled();
    G4ThreeVector fMomHalf = GetInfo(aTrack)->GetMomentumChanneled();
    G4ThreeVector fPosHalf = GetInfo(aTrack)->GetPositionChanneled();

    if(GetXPL(aTrack)->IsBent()){
            fIntegrationPeriod = (vPositionPost.phi() - vPositionPre.phi())*
                    GetXPL(aTrack)->GetCurvatureRadius().x();
            fIntegrationPeriod = vPositionPost.y() - vPositionPre.y();
    }
    else{
            fIntegrationPeriod = vPositionPost.z() - vPositionPre.z();
    }

    fTimeStepTotal = 0.;

    G4double vNucleiDensity=0.;
    G4double vElectronDensity=0.;

    if(fIntegrationPeriod>0. && bHasToComputeTrajectory==true){
            G4double kBeta = 0.;
            G4double kPos = 0.;
            G4double kMom = 0.;
            G4double kBR = 0.;
            G4double Z = 0.;
        do{
            UpdateIntegrationStep(aTrack,fMom);

            fPosHalf = fPos;
            fMomHalf = fMom;

            kBeta = aTrack.GetVelocity()/c_light;
            if(fMom.z()!=0.){
              kPos = fTimeStep / fMom.z();
            }
            else{
              kPos = fTimeStep / 1.E-20;
            }
            kMom = fTimeStep / kBeta;
            kBR = fTimeStep * (fMom.z() * kBeta);;
            Z = GetParticleDefinition(aTrack)->GetPDGCharge();

            fPosHalf += (fMom * kPos * 0.5);
            fMomHalf += 
                    (GetElectricField()->GetEC(fPos,GetXPL(aTrack))
                    * Z  * kMom * 0.5);

            if(GetXPL(aTrack)->IsBent()){
                    G4double temp =
                            fMomHalf.x() + kBR * 0.5 /
                            (GetXPL(aTrack)->GetCurvatureRadius()).x();
                fMomHalf.setX(temp);
            }

            fPos += (fMomHalf * kPos);
            fMom += 
                    (GetElectricField()->GetEC(fPosHalf,GetXPL(aTrack))
                     * Z * kMom );

            if(GetXPL(aTrack)->IsBent()){
                    G4double temp = 
                            fMom.x() + kBR / 
                            (GetXPL(aTrack)->GetCurvatureRadius()).x();
               fMom.setX(temp);
            }

            fTimeStepTotal += fTimeStep;

            vNucleiDensity += 
                 (fTimeStep * 
                 (GetNucleiDensity()->GetEC(fPos,GetXPL(aTrack)).x()
                 +GetNucleiDensity()->GetEC(fPos,GetXPL(aTrack)).x()
                 ) * 0.5);
            vElectronDensity +=
                 (fTimeStep * (
                 GetElectronDensity()->GetEC(fPos,GetXPL(aTrack)).x() + 
                 GetElectronDensity()->GetEC(fPos,GetXPL(aTrack)).x()) * 0.5);


        } while(fTimeStepTotal<fIntegrationPeriod);

        vNucleiDensity /= fIntegrationPeriod;
        vElectronDensity /= fIntegrationPeriod;
        GetInfo(aTrack)->SetNucleiDensity(vNucleiDensity);
        GetInfo(aTrack)->SetElectronDensity(vElectronDensity);
    }
    else{
        ResetDensity(aTrack);
    }
    
    GetInfo(aTrack)->SetMomentumChanneled(fMom);
    GetInfo(aTrack)->SetPositionChanneled(fPos);
    
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

bHasToComputeTrajectory

G4bool ExExChProcessChanneling::bHasToComputeTrajectory

private

Definition at line 173 of file ExExChProcessChanneling.hh.

bPointYPost

G4double ExExChProcessChanneling::bPointYPost

private

Definition at line 174 of file ExExChProcessChanneling.hh.

bPointYPre

G4double ExExChProcessChanneling::bPointYPre

private

Definition at line 175 of file ExExChProcessChanneling.hh.

fElectricField

XVCrystalCharacteristic* ExExChProcessChanneling::fElectricField

private

Definition at line 158 of file ExExChProcessChanneling.hh.

fElectronDensity

XVCrystalCharacteristic* ExExChProcessChanneling::fElectronDensity

private

Definition at line 162 of file ExExChProcessChanneling.hh.

fFileCharacteristicsName

G4String ExExChProcessChanneling::fFileCharacteristicsName

private

Definition at line 164 of file ExExChProcessChanneling.hh.

fIntegratedDensity

XCrystalIntegratedDensityHub* ExExChProcessChanneling::fIntegratedDensity

private

Definition at line 159 of file ExExChProcessChanneling.hh.

fIntegrationPeriod

G4double ExExChProcessChanneling::fIntegrationPeriod

private

Definition at line 178 of file ExExChProcessChanneling.hh.

fLatticeManager

XLatticeManager3* ExExChProcessChanneling::fLatticeManager

private

Definition at line 155 of file ExExChProcessChanneling.hh.

fNucleiDensity

XVCrystalCharacteristic* ExExChProcessChanneling::fNucleiDensity

private

Definition at line 161 of file ExExChProcessChanneling.hh.

fPotentialEnergy

XVCrystalCharacteristic* ExExChProcessChanneling::fPotentialEnergy

private

Definition at line 157 of file ExExChProcessChanneling.hh.

fTimeStep

G4double ExExChProcessChanneling::fTimeStep

private

Definition at line 168 of file ExExChProcessChanneling.hh.

fTimeStepMax

G4double ExExChProcessChanneling::fTimeStepMax

private

Definition at line 170 of file ExExChProcessChanneling.hh.

fTimeStepMin

G4double ExExChProcessChanneling::fTimeStepMin

private

Definition at line 169 of file ExExChProcessChanneling.hh.

fTimeStepTotal

G4double ExExChProcessChanneling::fTimeStepTotal

private

Definition at line 171 of file ExExChProcessChanneling.hh.

fTransverseVariationMax

G4double ExExChProcessChanneling::fTransverseVariationMax

private

Definition at line 177 of file ExExChProcessChanneling.hh.

---

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

• ExExChProcessChanneling.hh
• ExExChProcessChanneling.cc