LBNEPerfectFocusProcess Class Reference

#include <LBNEPerfectFocusProcess.hh>

Inheritance diagram for LBNEPerfectFocusProcess:

Public Member Functions
	LBNEPerfectFocusProcess (const G4String &aName="pFocus", G4ProcessType aType=fGeneral)
virtual	~LBNEPerfectFocusProcess ()
LBNEPerfectFocusParticleChange *	PostStepDoIt (const G4Track &track, const G4Step &stepData)
G4double	PostStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
bool	IsApplicable (const G4ParticleDefinition &)
void	StartTracking (G4Track *aTrack)
G4double	GetMeanFreePath (const G4Track &, G4double, G4ForceCondition *)

Private Member Functions
	LBNEPerfectFocusProcess (const LBNEPerfectFocusProcess &)
LBNEPerfectFocusProcess &	operator= (const LBNEPerfectFocusProcess &right)
double	GetFreePath (const G4Track &track, G4double previousStepSize)

Private Attributes
double	fZCoordForPerfectFocusing
double	fRCoordOutOfTargetSq
double	fZAtTrigger
double	fZStart
double	fRAtTriggerSq
double	fRStartSq
LBNEPerfectFocusParticleChange *	fParticleChange

Detailed Description

Definition at line 26 of file LBNEPerfectFocusProcess.hh.

Constructor & Destructor Documentation

LBNEPerfectFocusProcess::LBNEPerfectFocusProcess	(	const G4String &	aName = "pFocus",
		G4ProcessType	aType = fGeneral
	)

Definition at line 17 of file LBNEPerfectFocusProcess.cc.

                                                                                            :
G4VDiscreteProcess(aName, aType)
 {
  enablePostStepDoIt = true;
  const G4RunManager *pRunManager = G4RunManager::GetRunManager();
  const LBNEDetectorConstruction *LBNEDetCr = reinterpret_cast<const LBNEDetectorConstruction*>(pRunManager->GetUserDetectorConstruction());
  fZCoordForPerfectFocusing = LBNEDetCr->GetZCoordForPerfectFocusing();
  const double rr = LBNEDetCr->GetRCoordOutOfTarget();
  fRCoordOutOfTargetSq = rr*rr;
  fParticleChange = 0;
//   std::cerr << "  LBNEPerfectFocusProcess::LBNEPerfectFocusProcess, got here!  fZCoordForPerfectFocusing = " 
//             << fZCoordForPerfectFocusing << " And quit " << std::endl; exit(2);
}

LBNEPerfectFocusProcess::~LBNEPerfectFocusProcess ( )

virtual

Definition at line 30 of file LBNEPerfectFocusProcess.cc.

{; }

LBNEPerfectFocusProcess::LBNEPerfectFocusProcess ( const LBNEPerfectFocusProcess &  )

private

Member Function Documentation

G4double LBNEPerfectFocusProcess::GetFreePath ( const G4Track &  track, G4double  previousStepSize  )

private

Definition at line 108 of file LBNEPerfectFocusProcess.cc.

                                                                                              {
  
   // In this context, we have no use for this 2nd parameter in the argument call. 
   // However, one can not change the interface, G4VDiscreteProcess OO design.. We use to flag a crazy 
   // value to avoid a compiler warning. (and burn some CPU cyvle, but it's good for the Grid economy. 
   // Paul Lebrun, Feb. 2015 
  
   if (previousStepSize < -999999) std::cerr << " LBNEPerfectFocusProcess::GetFreePath, crazy prev step size.. " << std::endl;
//   const LBNETrackInformation *oldTrInfo = reinterpret_cast<const LBNETrackInformation*>(aTrack.GetUserInformation());
//   if (previousStepSize < 1.0e-4) return previousStepSize;
//   std::cerr << "  LBNEPerfectFocusProcess::GetMeanFreePath, got here! flag = " << oldTrInfo->GetPFFlag() << std::endl;
//   if (oldTrInfo->GetPFFlag() == 1) return 1.0e103; // we are done,  the change of direction already occured. DOes not currently work!!!
   if (fZCoordForPerfectFocusing < 0. ) {
        const G4ThreeVector posT = aTrack.GetPosition(); 
        const double radSq= posT[0]*posT[0] + posT[1]*posT[1];
        if ((std::abs(radSq - fRCoordOutOfTargetSq) < 0.5*CLHEP::mm) && (posT[2] < 5000.*CLHEP::mm)) {
         // it is unlikely that we will ever have a target longer than 5 meters 
          fRAtTriggerSq = radSq;
          fZAtTrigger = posT[2];
//          std::cerr << "  LBNEPerfectFocusProcess::GetMeanFreePath, at crit. radius " << std::sqrt(rAtTriggerSq) << std::endl;
          return 1.0e-5*CLHEP::mm; 
        } else {
          return 1.0e103;
        }                                               
   } else {
     if(aTrack.GetPosition()[2] > fZCoordForPerfectFocusing && (fZStart < fZCoordForPerfectFocusing)) {
      // If the track has been created downstream of fZCoordForPerfectFocusing, via an other process, mean free path inf. 
        fZAtTrigger = aTrack.GetPosition()[2];
//        std::cerr << "  LBNEPerfectFocusProcess::GetMeanFreePath, At Z " << zAtTrigger << std::endl;
        return 0.00001; 
     } else {
       return 1.0e103;
     }
   }
}

G4double LBNEPerfectFocusProcess::GetMeanFreePath	(	const G4Track &	aTrack,
		G4double	previousStepSize,
		G4ForceCondition *	aCond
	)

Definition at line 100 of file LBNEPerfectFocusProcess.cc.

                                                                                                                           {
//  std::cerr << "  LBNEPerfectFocusProcess::GetMeanFreePath, at " << aTrack.GetPosition() << std::endl;
  *aCond = NotForced;
  return this->GetFreePath(aTrack, previousStepSize);
}

G4bool LBNEPerfectFocusProcess::IsApplicable

(

const G4ParticleDefinition &

pDef

)

Definition at line 144 of file LBNEPerfectFocusProcess.cc.

                                                                              {
  int pid = pDef.GetPDGEncoding();
  if (std::abs(pid) == 211) return true;
  if (std::abs(pid) == 321) return true;
  return false;
}

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

private

LBNEPerfectFocusParticleChange * LBNEPerfectFocusProcess::PostStepDoIt	(	const G4Track &	track,
		const G4Step &	stepData
	)

Definition at line 36 of file LBNEPerfectFocusProcess.cc.

                                                                                                                    {


   delete fParticleChange; // start by deleting the previous instance of the particle change.. 
   fParticleChange = 0;
   const G4DynamicParticle *pDef = aTrack.GetDynamicParticle();
   const int pId = pDef->GetDefinition()->GetPDGEncoding();
   if ((std::abs(pId) != 211) && (std::abs(pId) !=321)) return 0; // Should not occur
   const double totalP = pDef->GetTotalMomentum(); 
   const LBNETrackInformation *oldTrInfo = reinterpret_cast<const LBNETrackInformation*>(aTrack.GetUserInformation());
   if (oldTrInfo->GetPFFlag() == 1) return 0;
   
   // Now stack it's replacement. Define it as a secondary. 
   //
   LBNETrackInformation *newTrInfo = new LBNETrackInformation();
   newTrInfo->SetDecayCode(oldTrInfo->GetDecayCode());
   newTrInfo->SetTgen(oldTrInfo->GetTgen());
   newTrInfo->SetNImpWt(oldTrInfo->GetNImpWt());
   G4ThreeVector aNewPos(stepData.GetPostStepPoint()->GetPosition());
   //
   // Displace the track radially and in Z to avoid having it going through the perfect focusing again. 
   //
   aNewPos[2] += 1.*CLHEP::mm;
   const double phi = std::atan2(aNewPos[1], aNewPos[0]);
   aNewPos[0] += std::cos(phi)*1.*CLHEP::mm;
   aNewPos[1] += std::sin(phi)*1.*CLHEP::mm;
   newTrInfo->SetPFFlag(1);
   newTrInfo->SetDecayCode(oldTrInfo->GetDecayCode());
   newTrInfo->SetTgen(oldTrInfo->GetTgen());
   newTrInfo->SetNImpWt(oldTrInfo->GetNImpWt());
   //
   G4ThreeVector aNewP(0., 0., totalP);
   G4DynamicParticle *aNewPart =  new G4DynamicParticle(pDef->GetDefinition(), aNewP);
   G4Track *aNewTrack = new G4Track(aNewPart, aTrack.GetLocalTime(), aNewPos);
//   aNewTrack->SetUserInformation(newTrInfo); // It will get lost, G4 tracking Kernel does not bother to copy the User information. 
// So, we coCLHEP::mment this out... Sad... 
   delete newTrInfo;
   // 
   fParticleChange = new LBNEPerfectFocusParticleChange();
   fParticleChange->AddSecondary(aNewTrack);
   fParticleChange->ProposeTrackStatus( fStopAndKill );   
   // Check the flag.. 
   // 
//   std::cerr << " LBNEPerfectFocusProcess::PostStepDoIt .. Total P " << totalP 
//           << " Position " << aNewPos << " old Tr ID  " << aTrack.GetTrackID() 
//         << " New Id " << aNewTrack->GetTrackID() 
//         << " zAttrigger " << fZAtTrigger << " rAttrigger " << std::sqrt(fRAtTriggerSq) << std::endl;
//   const LBNETrackInformation *newTrInfoCheck = reinterpret_cast<const LBNETrackInformation*>(aNewTrack->GetUserInformation());
//   std::cerr << " Pointer for Tr User Info " <<  newTrInfoCheck << " New track PFFlag " << newTrInfoCheck->GetPFFlag() << std::endl;
   return fParticleChange;

}

G4double LBNEPerfectFocusProcess::PostStepGetPhysicalInteractionLength	(	const G4Track &	track,
		G4double	previousStepSize,
		G4ForceCondition *	condition
	)

Definition at line 92 of file LBNEPerfectFocusProcess.cc.

{
//  std::cerr << "  LBNEPerfectFocusProcess::GetPhysicalInteractionLength, at " << aTrack.GetPosition() << std::endl;
  *condition = NotForced;
  return this->GetFreePath(aTrack, previousStepSize);
}

void LBNEPerfectFocusProcess::StartTracking

(

G4Track *

aTrack

)

Definition at line 151 of file LBNEPerfectFocusProcess.cc.

                                                           {
//   const LBNETrackInformation *oldTrInfo = reinterpret_cast<const LBNETrackInformation*>(aTrack->GetUserInformation());
//   std::cerr << "  LBNEPerfectFocusProcess::StartTracking, id " << aTrack->GetTrackID() 
//             << " at  " << aTrack->GetPosition() << " fRCoordOutOfTargetSq " << fRCoordOutOfTargetSq << std::endl;
   fZAtTrigger = -1.0e103;
   const G4ThreeVector posT = aTrack->GetPosition(); 
   fZStart = posT[2];
   fRAtTriggerSq = posT[0]*posT[0] + posT[1]*posT[1];
             
//   exit(2);
}

Member Data Documentation

LBNEPerfectFocusParticleChange* LBNEPerfectFocusProcess::fParticleChange

mutableprivate

Definition at line 60 of file LBNEPerfectFocusProcess.hh.

double LBNEPerfectFocusProcess::fRAtTriggerSq

mutableprivate

Definition at line 58 of file LBNEPerfectFocusProcess.hh.

double LBNEPerfectFocusProcess::fRCoordOutOfTargetSq

private

Definition at line 55 of file LBNEPerfectFocusProcess.hh.

double LBNEPerfectFocusProcess::fRStartSq

mutableprivate

Definition at line 59 of file LBNEPerfectFocusProcess.hh.

double LBNEPerfectFocusProcess::fZAtTrigger

mutableprivate

Definition at line 56 of file LBNEPerfectFocusProcess.hh.

double LBNEPerfectFocusProcess::fZCoordForPerfectFocusing

private

Definition at line 54 of file LBNEPerfectFocusProcess.hh.

double LBNEPerfectFocusProcess::fZStart

mutableprivate

Definition at line 57 of file LBNEPerfectFocusProcess.hh.

---

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

• g4lbne/include/LBNEPerfectFocusProcess.hh
• g4lbne/src/LBNEPerfectFocusProcess.cc