G4TrackList Class Reference

#include <G4TrackList.hh>

Public Types
typedef G4TrackList_iterator	iterator

Public Member Functions
	G4TrackList ()
	~G4TrackList ()
G4Track *	back ()
G4int	size () const
bool	empty () const
iterator	insert (iterator, G4Track *)
iterator	begin ()
iterator	end ()
bool	Holds (const G4Track *) const
void	push_front (G4Track *__track)
void	push_back (G4Track *__track)
G4Track *	pop_back ()
void	remove (G4Track *)
iterator	pop (G4Track *)
iterator	pop (iterator __first, iterator __last)
iterator	erase (G4Track *)
iterator	erase (iterator __first, iterator __last)
void	transferTo (G4TrackList *)

Protected Member Functions
G4TrackListNode *	CreateNode (G4Track *)
G4TrackListNode *	Flag (G4Track *)
G4TrackListNode *	Unflag (G4Track *)
void	CheckFlag (G4TrackListNode *)
void	DeleteTrack (G4Track *)
void	Hook (G4TrackListNode *, G4TrackListNode *)
void	Unhook (G4TrackListNode *)
G4TrackListNode *	EraseTrackListNode (G4Track *)

Detailed Description

G4TrackList is used by G4ITStepManager to save G4IT tracks only. Its advantage lies to a fast search of a track in this list.

Definition at line 106 of file G4TrackList.hh.

Member Typedef Documentation

typedef G4TrackList_iterator G4TrackList::iterator

Definition at line 120 of file G4TrackList.hh.

Constructor & Destructor Documentation

G4TrackList::G4TrackList

(

)

Definition at line 77 of file G4TrackList.cc.

References G4TrackListNode::fAttachedToList, G4TrackListNode::SetNext(), and G4TrackListNode::SetPrevious().

                         : fBoundary()
{
    fListRef    = new _ListRef(this);
    fpStart      = 0;
    fpFinish     = 0;
    fNbTracks   = 0 ;
    fBoundary.SetPrevious(&fBoundary);
    fBoundary.SetNext(&fBoundary);
    fBoundary.fAttachedToList = true;
}

G4TrackList::~G4TrackList

(

)

Definition at line 107 of file G4TrackList.cc.

References DeleteTrack(), G4TrackListNode::GetNext(), and G4TrackListNode::GetTrack().

{
    if( fNbTracks != 0 )
    {
        G4TrackListNode * __stackedTrack = fpStart;
        G4TrackListNode * __nextStackedTrack;

        // delete tracks in the stack
        while(  __stackedTrack && __stackedTrack != &(fBoundary) )
        {
            __nextStackedTrack = __stackedTrack->GetNext();
            G4Track* __track = __stackedTrack->GetTrack();

            delete __stackedTrack;
            __stackedTrack = 0;

            if(__track)
            {
                //////////////
                DeleteTrack(__track);
                __track = 0;
                //////////////
            }

            __stackedTrack = __nextStackedTrack;
        }
    }
    fNbTracks = 0;
}

Member Function Documentation

G4Track* G4TrackList::back ( )

inline

Definition at line 125 of file G4TrackList.hh.

References G4TrackListNode::GetTrack().

    {
        if(fNbTracks != 0)
            return fpFinish->GetTrack();
        else return 0 ;
    }

G4TrackList::iterator G4TrackList::begin ( )

inline

Definition at line 271 of file G4TrackList.hh.

Referenced by push_front().

{ return iterator(fpStart); }

void G4TrackList::CheckFlag ( G4TrackListNode *  __trackListNode )

protected

Definition at line 269 of file G4TrackList.cc.

References FatalErrorInArgument, _ListRef::fpTrackList, G4endl, G4Exception(), GetIT(), G4IT::GetName(), G4TrackListNode::GetTrack(), and G4Track::GetTrackID().

Referenced by Unflag().

{
    if(__trackListNode -> fListRef->fpTrackList != this)
    {
        G4Track* track = __trackListNode->GetTrack();
        G4ExceptionDescription exceptionDescription ;
        exceptionDescription
                << "The track "<< GetIT(track)->GetName()
                << " with trackID " << track->GetTrackID()
                << " is not correctly linked to a TrackList."
                << G4endl
                << "You are probably trying to withdraw this track "
                << "from the list but it probably does not belong to "
                << "this track list." << G4endl;
        G4Exception("G4TrackList::CheckFlag","G4TrackList002",
                    FatalErrorInArgument,exceptionDescription);
    }
}

G4TrackListNode * G4TrackList::CreateNode ( G4Track *  __track )

protected

Complexity = constant

Definition at line 170 of file G4TrackList.cc.

References Flag().

Referenced by insert().

{
    G4TrackListNode* __trackListNode = Flag(__track);
    return __trackListNode;
}

void G4TrackList::DeleteTrack ( G4Track *  __track )

protected

Definition at line 335 of file G4TrackList.cc.

References G4Step::DeleteSecondaryVector(), G4Step::GetfSecondary(), and G4Track::GetStep().

Referenced by erase(), and ~G4TrackList().

{
    G4Step* __step = const_cast<G4Step*>(__track->GetStep());
    if(__step)
    {
        if(__step->GetfSecondary()) __step->DeleteSecondaryVector();
        delete __step;
    }
    delete __track;
}

bool G4TrackList::empty ( ) const

inline

Definition at line 267 of file G4TrackList.hh.

{ return (fNbTracks == 0); }

G4TrackList::iterator G4TrackList::end ( )

inline

Definition at line 274 of file G4TrackList.hh.

Referenced by push_back().

{ return iterator( &(fBoundary) ); }

G4TrackList::iterator G4TrackList::erase

(

G4Track *

__track

)

Definition at line 346 of file G4TrackList.cc.

References DeleteTrack(), and EraseTrackListNode().

Referenced by erase(), and remove().

{
    G4TrackListNode* __next_node = EraseTrackListNode(__track);
    //////////////////
    DeleteTrack(__track);
    __track = 0;
    //////////////////
    iterator __next(__next_node);
    return __next;
}

G4TrackList::iterator G4TrackList::erase	(	iterator	__first,
		iterator	__last
	)

Complexity = constant By storing the node inside the object, we avoid searching through all the container.

Definition at line 377 of file G4TrackList.cc.

References erase().

{
    if(fNbTracks == 0) return iterator(&fBoundary);

    while (__first != __last)
    {
        if(__first . fpNode)
            __first = erase(*__first);
    }
    return __last;
}

G4TrackListNode * G4TrackList::EraseTrackListNode ( G4Track *  __track )

protected

Definition at line 325 of file G4TrackList.cc.

References GetIT(), G4TrackListNode::GetNext(), G4IT::SetTrackListNode(), Unflag(), and Unhook().

Referenced by erase().

{
    G4TrackListNode* __node = Unflag(__track);
    GetIT(__track)->SetTrackListNode(0);
    G4TrackListNode* __next = __node->GetNext();
    Unhook(__node);
    delete __node;
    return __next;
}

G4TrackListNode * G4TrackList::Flag ( G4Track *  __track )

protected

Definition at line 142 of file G4TrackList.cc.

References FatalErrorInArgument, G4TrackListNode::fAttachedToList, G4TrackListNode::fListRef, G4Exception(), GetIT(), G4IT::GetName(), G4IT::GetTrackListNode(), and G4IT::SetTrackListNode().

Referenced by CreateNode().

{
    G4IT* __iTrack = GetIT(__track);
    G4TrackListNode* __trackListNode = __iTrack->GetTrackListNode();

    if(__trackListNode != 0)
    {
        // Suggestion move the node to this list
        if(__trackListNode->fAttachedToList)
        {
            G4ExceptionDescription exceptionDescription ;
            exceptionDescription << "This track "<< __iTrack->GetName() ;
            exceptionDescription << " is already attached to a TrackList ";
            G4Exception("G4TrackList::Flag","G4TrackList001",
                        FatalErrorInArgument,exceptionDescription);
         }
    }
    else
    {
        __trackListNode = new G4TrackListNode(__track);
        __iTrack->SetTrackListNode(__trackListNode);
    }

    __trackListNode->fAttachedToList = true;
    __trackListNode->fListRef = fListRef;
    return __trackListNode;
}

bool G4TrackList::Holds

(

const G4Track *

track

)

const

return an iterator that contains an empty node use for boundary checking only

Definition at line 137 of file G4TrackList.cc.

References _ListRef::fpTrackList, and GetIT().

{
    return (GetIT(track)->GetTrackListNode()->fListRef->fpTrackList == this)  ;
}

void G4TrackList::Hook ( G4TrackListNode *  __position, G4TrackListNode *  __toHook  )

protected

Definition at line 176 of file G4TrackList.cc.

References G4TrackListNode::GetPrevious(), G4TrackListNode::SetNext(), and G4TrackListNode::SetPrevious().

Referenced by insert().

{
    if(fNbTracks == 0)
    {
        // DEBUG
        //        G4cout << "fNbTracks == 0" << G4endl;
        fpStart = __toHook;
        fpFinish = __toHook;
        __toHook->SetNext(&fBoundary);
        __toHook->SetPrevious(&fBoundary);
        fBoundary.SetNext(__toHook);
        fBoundary.SetPrevious(__toHook);
    }
    else if( __position == &fBoundary)
    {
        // DEBUG
        //        G4cout << "__position == &fBoundary" << G4endl;
        fpFinish->SetNext( __toHook );
        __toHook->SetPrevious( fpFinish );

        __toHook->SetNext(&fBoundary);
        fBoundary.SetPrevious( __toHook );

        fpFinish = __toHook;
    }
    else if( __position == fpStart )
    {
        // DEBUG
        //        G4cout << "__position == fStart" << G4endl;
        __toHook->SetPrevious( &fBoundary );
        fBoundary.SetNext(__toHook);
        __toHook->SetNext(fpStart);
        fpStart->SetPrevious(__toHook);
        fpStart = __toHook;
    }
    else
    {
        // DEBUG
        //        G4cout << "else" << G4endl;
        G4TrackListNode* __previous = __position->GetPrevious();
        __toHook->SetPrevious(__previous);
        __toHook->SetNext(__position);
        __position->SetPrevious(__toHook);
        __previous->SetNext(__toHook);
    }

    fNbTracks++;
}

G4TrackList::iterator G4TrackList::insert	(	G4TrackList::iterator	__position,
		G4Track *	__track
	)

Definition at line 258 of file G4TrackList.cc.

References CreateNode(), and Hook().

Referenced by push_back(), and push_front().

{
    G4TrackListNode* __node = CreateNode(__track);
    Hook(__position.fpNode, __node);
    return iterator(__node);
}

G4TrackList::iterator G4TrackList::pop

(

G4Track *

__track

)

Definition at line 317 of file G4TrackList.cc.

References G4TrackListNode::GetNext(), Unflag(), and Unhook().

Referenced by pop().

{
    G4TrackListNode* __node = Unflag(__track);
    iterator __next(__node->GetNext());
    Unhook(__node);
    return __next;
}

G4TrackList::iterator G4TrackList::pop	(	iterator	__first,
		iterator	__last
	)

Definition at line 363 of file G4TrackList.cc.

References pop().

{
    if(fNbTracks == 0) return iterator(&fBoundary);

    while (__first != __last)
    {
        if(__first . fpNode)
            __first = pop(*__first);
    }
    return __last;
}

G4Track * G4TrackList::pop_back

(

)

Definition at line 308 of file G4TrackList.cc.

References G4TrackListNode::GetTrack(), Unflag(), and Unhook().

{
    if( fNbTracks == 0 ) return 0;
    G4TrackListNode * __aStackedTrack = fpFinish;
    Unhook( __aStackedTrack );
    Unflag( __aStackedTrack->GetTrack() );
    return __aStackedTrack->GetTrack();
}

void G4TrackList::push_back ( G4Track *  __track )

inline

Definition at line 284 of file G4TrackList.hh.

References end(), and insert().

{
    insert(end(), track);
}

void G4TrackList::push_front ( G4Track *  __track )

inline

Definition at line 279 of file G4TrackList.hh.

References begin(), and insert().

{
    insert(begin(), track);
}

void G4TrackList::remove

(

G4Track *

__track

)

Definition at line 357 of file G4TrackList.cc.

References erase().

{
    this->erase(__track);
}

G4int G4TrackList::size ( ) const

inline

Definition at line 131 of file G4TrackList.hh.

    {
        return fNbTracks;
    }

void G4TrackList::transferTo

(

G4TrackList *

__destination

)

Complexity = linear in size between __first and __last

Definition at line 389 of file G4TrackList.cc.

References _ListRef::fpTrackList, G4TrackListNode::SetNext(), and G4TrackListNode::SetPrevious().

{
    if(fNbTracks==0) return;

    if(__destination->fNbTracks == 0)
    {
        __destination->fpStart       =    this->fpStart ;
        __destination->fpFinish      =    this->fpFinish ;
        __destination->fNbTracks    =    this->fNbTracks;

        __destination->fBoundary.SetNext(fpStart);
        __destination->fBoundary.SetPrevious(fpFinish);

        __destination->fpFinish->SetNext(&__destination->fBoundary);
        __destination->fpStart->SetPrevious(&__destination->fBoundary);
    }
    else
    {
        this->fpStart->SetPrevious(__destination->fpFinish);
        __destination->fpFinish->SetNext(this->fpStart);
        __destination->fBoundary.SetPrevious(this->fpFinish);
        this->fpFinish->SetNext(&__destination->fBoundary);

        __destination->fpFinish = this->fpFinish;
        __destination->fNbTracks += this->fNbTracks;
    }

    fNbTracks = 0;
    fpStart = 0;
    fpFinish = 0;
    this->fBoundary.SetPrevious(&this->fBoundary);
    this->fBoundary.SetNext(&this->fBoundary);

    fListRef->fpTrackList = __destination;
}

G4TrackListNode * G4TrackList::Unflag ( G4Track *  __track )

protected

Definition at line 288 of file G4TrackList.cc.

References CheckFlag(), FatalErrorInArgument, G4TrackListNode::fAttachedToList, G4TrackListNode::fListRef, G4Exception(), GetIT(), G4IT::GetName(), and G4IT::GetTrackListNode().

Referenced by EraseTrackListNode(), pop(), and pop_back().

{
    G4IT* __IT = GetIT(__track);
    G4TrackListNode* __trackListNode = __IT->GetTrackListNode();
    // TODO : complete the exception
    if(__trackListNode == 0)
    {
        G4ExceptionDescription exceptionDescription ;
        exceptionDescription << "This track "<< GetIT(__track)->GetName() ;
        exceptionDescription << " was not connected to any trackList ";
        G4Exception("G4TrackList::Unflag","G4TrackList003",
                    FatalErrorInArgument,exceptionDescription);
        return 0;
    }
    CheckFlag(__trackListNode);
    __trackListNode->fAttachedToList = false;
    __trackListNode->fListRef = 0;
    return __trackListNode;
}

void G4TrackList::Unhook ( G4TrackListNode *  __toUnHook )

protected

Definition at line 225 of file G4TrackList.cc.

References G4TrackListNode::GetNext(), G4TrackListNode::GetPrevious(), G4TrackListNode::SetNext(), and G4TrackListNode::SetPrevious().

Referenced by EraseTrackListNode(), pop(), and pop_back().

{
    G4TrackListNode* __previous = __toUnHook->GetPrevious();
    G4TrackListNode* __next = __toUnHook->GetNext();

    __toUnHook->SetPrevious(0);
    __toUnHook->SetNext(0);

    if( fNbTracks == 1 )
    {
        fpStart = 0;
        fpFinish = 0;
    }
    else
    {
        if(__toUnHook == fpFinish)
        {
            fpFinish = __previous;
        }
        if(__toUnHook == fpStart)
        {
            fpStart = __next;
        }
    }

    // There should be always a __next and a __previous
    // because it is a circle link
    __next->SetPrevious(__previous);
    __previous->SetNext(__next);

    fNbTracks--;
}

---

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

• G4TrackList.hh
• G4TrackList.cc