Gabriele Cosmo
206 lines
5.2 KiB
Plaintext
206 lines
5.2 KiB
Plaintext
//
|
|
// ********************************************************************
|
|
// * DISCLAIMER *
|
|
// * *
|
|
// * The following disclaimer summarizes all the specific disclaimers *
|
|
// * of contributors to this software. The specific disclaimers,which *
|
|
// * govern, are listed with their locations in: *
|
|
// * http://cern.ch/geant4/license *
|
|
// * *
|
|
// * Neither the authors of this software system, nor their employing *
|
|
// * institutes,nor the agencies providing financial support for this *
|
|
// * work make any representation or warranty, express or implied, *
|
|
// * regarding this software system or assume any liability for its *
|
|
// * use. *
|
|
// * *
|
|
// * This code implementation is the intellectual property of the *
|
|
// * GEANT4 collaboration. *
|
|
// * By copying, distributing or modifying the Program (or any work *
|
|
// * based on the Program) you indicate your acceptance of this *
|
|
// * statement, and all its terms. *
|
|
// ********************************************************************
|
|
//
|
|
//
|
|
// $Id: G4NavigationHistory.icc,v 1.7 2002/07/23 08:50:35 gcosmo Exp $
|
|
// GEANT4 tag $Name: geant4-05-00 $
|
|
//
|
|
//
|
|
// class G4NavigationHistory Inline implementation
|
|
//
|
|
// ********************************************************************
|
|
|
|
inline
|
|
G4NavigationHistory&
|
|
G4NavigationHistory::operator=(const G4NavigationHistory &h)
|
|
{
|
|
if (&h == this) return *this;
|
|
|
|
// fNavHistory=h.fNavHistory; // This works, but is very slow.
|
|
|
|
if( this->GetMaxDepth() < h.fStackDepth )
|
|
{
|
|
fNavHistory.resize( h.fStackDepth );
|
|
}
|
|
for ( register G4int ilev=h.fStackDepth; ilev>=0; ilev-- )
|
|
{
|
|
fNavHistory[ilev] = h.fNavHistory[ilev];
|
|
}
|
|
fStackDepth=h.fStackDepth;
|
|
|
|
return *this;
|
|
}
|
|
|
|
inline
|
|
void G4NavigationHistory::Reset()
|
|
{
|
|
fStackDepth=0;
|
|
}
|
|
|
|
inline
|
|
void G4NavigationHistory::Clear()
|
|
{
|
|
G4AffineTransform dummyTransform(G4ThreeVector(0.));
|
|
|
|
G4NavigationLevel tmpNavLevel;
|
|
tmpNavLevel=G4NavigationLevel(0, dummyTransform, kParameterised, -1) ;
|
|
|
|
Reset();
|
|
for (register G4int ilev=fNavHistory.size()-1; ilev>=0; ilev--)
|
|
{
|
|
// fNavHistory(ilev)= 0;
|
|
fNavHistory[ilev]= tmpNavLevel;
|
|
}
|
|
}
|
|
|
|
inline
|
|
void G4NavigationHistory::SetFirstEntry(G4VPhysicalVolume* pVol)
|
|
{
|
|
G4ThreeVector translation(0.,0.,0.);
|
|
|
|
// Protection needed in case pVol=null
|
|
// so that a touchable-history can signal OutOfWorld
|
|
//
|
|
if( pVol!=0 )
|
|
{
|
|
translation=pVol->GetTranslation();
|
|
}
|
|
fNavHistory[0] =
|
|
G4NavigationLevel( pVol, G4AffineTransform(translation), kNormal );
|
|
}
|
|
|
|
inline
|
|
const G4AffineTransform* G4NavigationHistory::GetPtrTopTransform() const
|
|
{
|
|
return fNavHistory[fStackDepth].GetPtrTransform();
|
|
}
|
|
|
|
inline
|
|
const G4AffineTransform& G4NavigationHistory::GetTopTransform() const
|
|
{
|
|
return fNavHistory[fStackDepth].GetTransform();
|
|
}
|
|
|
|
inline
|
|
G4int G4NavigationHistory::GetTopReplicaNo() const
|
|
{
|
|
return fNavHistory[fStackDepth].GetReplicaNo();
|
|
}
|
|
|
|
inline
|
|
EVolume G4NavigationHistory::GetTopVolumeType() const
|
|
{
|
|
return fNavHistory[fStackDepth].GetVolumeType();
|
|
}
|
|
|
|
inline
|
|
G4VPhysicalVolume* G4NavigationHistory::GetTopVolume() const
|
|
{
|
|
return fNavHistory[fStackDepth].GetPhysicalVolume();
|
|
}
|
|
|
|
inline
|
|
G4int G4NavigationHistory::GetDepth() const
|
|
{
|
|
return fStackDepth;
|
|
}
|
|
|
|
inline
|
|
const G4AffineTransform&
|
|
G4NavigationHistory::GetTransform(G4int n) const
|
|
{
|
|
return fNavHistory[n].GetTransform();
|
|
}
|
|
|
|
inline
|
|
G4int G4NavigationHistory::GetReplicaNo(G4int n) const
|
|
{
|
|
return fNavHistory[n].GetReplicaNo();
|
|
}
|
|
|
|
inline
|
|
EVolume G4NavigationHistory::GetVolumeType(G4int n) const
|
|
{
|
|
return fNavHistory[n].GetVolumeType();
|
|
}
|
|
|
|
inline
|
|
G4VPhysicalVolume* G4NavigationHistory::GetVolume(G4int n) const
|
|
{
|
|
return fNavHistory[n].GetPhysicalVolume();
|
|
}
|
|
|
|
inline
|
|
G4int G4NavigationHistory::GetMaxDepth() const
|
|
{
|
|
return fNavHistory.size();
|
|
}
|
|
|
|
inline
|
|
void G4NavigationHistory::BackLevel()
|
|
{
|
|
assert( fStackDepth>0 );
|
|
|
|
// Tell the level that I am forgetting it
|
|
// delete fNavHistory(fStackDepth);
|
|
//
|
|
fStackDepth--;
|
|
}
|
|
|
|
inline
|
|
void G4NavigationHistory::BackLevel(G4int n)
|
|
{
|
|
assert( n<=fStackDepth );
|
|
fStackDepth-=n;
|
|
}
|
|
|
|
inline
|
|
void G4NavigationHistory::EnlargeHistory()
|
|
{
|
|
G4int len = fNavHistory.size();
|
|
if ( len==fStackDepth )
|
|
{
|
|
// Note: Resize operation clears additional entries
|
|
//
|
|
G4int nlen = len+kHistoryStride;
|
|
fNavHistory.resize(nlen);
|
|
}
|
|
}
|
|
|
|
|
|
inline
|
|
void G4NavigationHistory::NewLevel( G4VPhysicalVolume *pNewMother,
|
|
EVolume vType,
|
|
G4int nReplica )
|
|
{
|
|
EnlargeHistory(); // Enlarge if required
|
|
fStackDepth++;
|
|
fNavHistory[fStackDepth] =
|
|
G4NavigationLevel( pNewMother,
|
|
fNavHistory[fStackDepth-1].GetTransform(),
|
|
G4AffineTransform(pNewMother->GetRotation(),
|
|
pNewMother->GetTranslation()),
|
|
vType,
|
|
nReplica );
|
|
// The constructor computes the new global->local transform
|
|
}
|