HyperbolaStep Class Reference

#include <HyperbolaStep.h>

Collaboration diagram for HyperbolaStep:

Public Member Functions
	HyperbolaStep (const HyperbolaStepper *stepper, InfracolorForce &string, const G4Track &track)
	~HyperbolaStep ()
void	PrepareNextStep ()
void	Step (G4double length)
void	Dump (G4double y[])
HyperbolaStep *	GetPrev () const
std::deque< StringVector >::const_iterator	GetStringPtr () const
G4double	GetFracLeft () const
G4bool	IsBoostLimited () const
G4double	GetMaxLength () const
G4double	GetLength () const
const StringVector &	GetStringOut () const
const G4LorentzVector &	GetMomentum () const

Private Attributes
const HyperbolaStepper *	m_stepper
std::deque< StringVector >::const_iterator	m_stringPtr
std::deque< StringVector >::const_iterator	m_stringEnd
G4double	m_fracLeft
G4ThreeVector	m_position
G4double	m_time
G4LorentzVector	m_momentum
StringVector	m_stringIn
G4double	m_maxFracTaken
StringVector	m_stringOut
G4double	m_maxLength
G4double	m_length

Detailed Description

Definition at line 17 of file HyperbolaStep.h.

Constructor & Destructor Documentation

HyperbolaStep()

HyperbolaStep::HyperbolaStep	(	const HyperbolaStepper *	stepper,
		InfracolorForce &	string,
		const G4Track &	track
	)

Definition at line 14 of file HyperbolaStep.cxx.

                                                                                                           :
    m_stepper(stepper),
    m_stringPtr(string.GetStringVectors().begin()),
    m_stringEnd(string.GetStringVectors().end()),
    m_fracLeft(1.0),
    m_position(track.GetPosition()),
    m_time(track.GetGlobalTime()),
    m_momentum(track.GetDynamicParticle()->Get4Momentum()),
    m_stringIn(0,0,0,0),
    m_maxFracTaken(1.0),
    m_stringOut(0,0,0,0),
    m_maxLength(0.0),
    m_length(0.0)
{}

~HyperbolaStep()

HyperbolaStep::~HyperbolaStep

(

)

Definition at line 29 of file HyperbolaStep.cxx.

{}

Member Function Documentation

Dump()

void HyperbolaStep::Dump

(

G4double

y[]

)

Definition at line 121 of file HyperbolaStep.cxx.

                                     {
    y[0] = m_position.x();
    y[1] = m_position.y();
    y[2] = m_position.z();
    y[3] = m_momentum.x();
    y[4] = m_momentum.y();
    y[5] = m_momentum.z();
    y[6] = m_momentum.t() - m_stepper->GetMass();
    y[7] = m_time;
    y[8] = m_length;
}

GetFracLeft()

G4double HyperbolaStep::GetFracLeft ( ) const

inline

Definition at line 53 of file HyperbolaStep.h.

{return m_fracLeft;}

GetLength()

G4double HyperbolaStep::GetLength ( ) const

inline

Definition at line 56 of file HyperbolaStep.h.

{return m_length;}

GetMaxLength()

G4double HyperbolaStep::GetMaxLength ( ) const

inline

Definition at line 55 of file HyperbolaStep.h.

{return m_maxLength;}

GetMomentum()

const G4LorentzVector & HyperbolaStep::GetMomentum ( ) const

inline

Definition at line 58 of file HyperbolaStep.h.

{return m_momentum;}

GetPrev()

HyperbolaStep* HyperbolaStep::GetPrev

(

)

const

GetStringOut()

const StringVector & HyperbolaStep::GetStringOut ( ) const

inline

Definition at line 57 of file HyperbolaStep.h.

{return m_stringOut;}

GetStringPtr()

std::deque< StringVector >::const_iterator HyperbolaStep::GetStringPtr ( ) const

inline

Definition at line 52 of file HyperbolaStep.h.

{return m_stringPtr;}

IsBoostLimited()

G4bool HyperbolaStep::IsBoostLimited ( ) const

inline

Definition at line 54 of file HyperbolaStep.h.

{return m_maxFracTaken != 1.0;}

PrepareNextStep()

void HyperbolaStep::PrepareNextStep

(

)

Definition at line 31 of file HyperbolaStep.cxx.

                                    {
    if (m_stringPtr == m_stringEnd) {
        // End of string vectors
        m_stringIn.set(0,0,0,0);
        m_stringOut.set(0,0,0,0);
        m_maxLength = m_length;
    } else {
        G4double force = m_stepper->GetForce();
        G4double mass = m_stepper->GetMass();
 
        // Get incoming string vector
        m_stringIn = (*m_stringPtr) * m_fracLeft;
        m_maxFracTaken = 1.0;
 
        // Find maximum remaining boost allowed for this step
        G4double gamma0 = std::max(m_momentum * m_stepper->GetStartMomentum() / sqr(mass), 1.0);
        G4double expRapidity0 = gamma0 + std::sqrt(sqr(gamma0) - 1);
        G4double maxExpRapidity = std::max(m_stepper->GetMaxExpRapidity() / expRapidity0, 1.0);
 
        // Reduce string vector if boost too large
        G4double tmp = 2 * force * m_stringIn.lv() * m_momentum / sqr(mass);
        if (tmp > maxExpRapidity - 1) {
            m_maxFracTaken = (maxExpRapidity - 1) / tmp;
            m_stringIn *= m_maxFracTaken;
        }
 
        // Reflect string vector and compute maximum step length
        m_stringOut = m_stringIn.reflect(m_momentum + force * m_stringIn.lv());
        m_maxLength = m_length + (m_stringIn.lv() + m_stringOut.lv()).rho();
    }
}

Step()

void HyperbolaStep::Step

(

G4double

length

)

Definition at line 63 of file HyperbolaStep.cxx.

                                        {
    //G4cout << "steplength/maxlength: " << length << " / " << m_maxLength << G4endl;
    G4double force = m_stepper->GetForce();
    G4double mass = m_stepper->GetMass();
 
    // Cut step to proper length
    G4double fracTaken = m_maxFracTaken;
    if (length < m_maxLength) {
        if (length > m_length) {
            // Calculate fraction of string vector to next-to-leading order in step length
            G4double currMaxLength = m_maxLength - m_length;
            for (G4int i = 0; i < 2 && currMaxLength > 0; i++) {
                G4double r = (length - m_length) / currMaxLength;
                m_stringIn *= r;
                m_stringOut = m_stringIn.reflect(m_momentum + force * m_stringIn.lv());
                fracTaken *= r;
                currMaxLength = (m_stringIn.lv() + m_stringOut.lv()).rho();
            }
        } else {
            m_stringIn.set(0,0,0,0);
            m_stringOut.set(0,0,0,0);
            fracTaken = 0.0;
        }
    }
    m_length = length;
 
    // Advance string pointer
    m_fracLeft *= (1 - fracTaken);
    if (m_fracLeft <= 0.0) {
        if (m_stringPtr != m_stringEnd) ++m_stringPtr;
        m_fracLeft = 1.0;
    }
 
    // Update position, momentum
    G4LorentzVector dPosition = m_stringIn.lv() + m_stringOut.lv();
    m_position += dPosition.vect();
    G4double dTime = dPosition.t() / CLHEP::c_light;
    m_time += dTime;
    m_momentum += force * (m_stringIn.lv() - m_stringOut.lv());
 
    // Field
    if (m_stepper->GetField() != 0) {
        G4ThreeVector p = m_position - dPosition.vect()/2;
        G4double point[4] = {p.x(), p.y(), p.z(), m_time - dTime/2};
        G4double field[6] = {0};
        m_stepper->GetField()->GetFieldValue(point, field);
        G4ThreeVector B(field[0], field[1], field[2]);
        G4ThreeVector E(field[3], field[4], field[5]);
        G4double charge = m_stepper->GetCharge();
        G4ThreeVector dMomField = E * dTime + dPosition.vect().cross(B);
        m_momentum += charge * G4LorentzVector(CLHEP::c_light * dMomField, E * dPosition.vect());
    }
 
    // Renormalize 4-momentum (TODO: address possible instability)
    m_momentum *= mass / m_momentum.m();
}

Member Data Documentation

m_fracLeft

G4double HyperbolaStep::m_fracLeft

private

Definition at line 40 of file HyperbolaStep.h.

m_length

G4double HyperbolaStep::m_length

private

Definition at line 49 of file HyperbolaStep.h.

m_maxFracTaken

G4double HyperbolaStep::m_maxFracTaken

private

Definition at line 46 of file HyperbolaStep.h.

m_maxLength

G4double HyperbolaStep::m_maxLength

private

Definition at line 48 of file HyperbolaStep.h.

m_momentum

G4LorentzVector HyperbolaStep::m_momentum

private

Definition at line 43 of file HyperbolaStep.h.

m_position

G4ThreeVector HyperbolaStep::m_position

private

Definition at line 41 of file HyperbolaStep.h.

m_stepper

const HyperbolaStepper* HyperbolaStep::m_stepper

private

Definition at line 36 of file HyperbolaStep.h.

m_stringEnd

std::deque<StringVector>::const_iterator HyperbolaStep::m_stringEnd

private

Definition at line 39 of file HyperbolaStep.h.

m_stringIn

StringVector HyperbolaStep::m_stringIn

private

Definition at line 45 of file HyperbolaStep.h.

m_stringOut

StringVector HyperbolaStep::m_stringOut

private

Definition at line 47 of file HyperbolaStep.h.

m_stringPtr

std::deque<StringVector>::const_iterator HyperbolaStep::m_stringPtr

private

Definition at line 38 of file HyperbolaStep.h.

m_time

G4double HyperbolaStep::m_time

private

Definition at line 42 of file HyperbolaStep.h.

---

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

• HyperbolaStep.h
• HyperbolaStep.cxx