MJWaveformChargePoint.hh

Go to the documentation of this file.

//---------------------------------------------------------------------------//
//bb0nubb0nubb0nubb0nubb0nubb0nubb0nubb0nubb0nubb0nubb0nubb0nubb0nubb0nubb0nu//
//                                                                           //
//                         MAJORANA Simulation                               //
//                                                                           //
//      This code implementation is the intellectual property of the         //
//      MAJORANA Collaboration. It is based on Geant4, an intellectual       //
//      property of the RD44 GEANT4 collaboration.                           //
//                                                                           //
//                        *********************                              //
//                                                                           //
//    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.    //
//    By copying, distributing or modifying the Program (or any work based   //
//    on on the Program) you indicate your acceptance of this statement,     //
//    and all its terms.                                                     //
//                                                                           //
//bb0nubb0nubb0nubb0nubb0nubb0nubb0nubb0nubb0nubb0nubb0nubb0nubb0nubb0nubb0nu//
//---------------------------------------------------------------------------//
// Begin description of class here
// End class description
//
// 
// --------------------------------------------------------------------------//
// --------------------------------------------------------------------------//

#ifndef _MJWAVEFORMCHARGEPOINT_HH
#define _MJWAVEFORMCHARGEPOINT_HH

//---------------------------------------------------------------------------//

#include <CLHEP/Vector/ThreeVector.h>
#include <CLHEP/Units/SystemOfUnits.h>


#include "waveform/MJVWaveformCrystal.hh"

//---------------------------------------------------------------------------//

class MJWaveformChargePoint 
{
public:

  //default constructor
  MJWaveformChargePoint(HepInt *location,
                        HepInt sign,
                        HepDouble eloss,
                        MJVWaveformCrystal *Xtal);

  //copy constructor
  MJWaveformChargePoint(const MJWaveformChargePoint &);

  //destructor
  ~MJWaveformChargePoint();

  //public interface

  void DoDiffusion(void);

  void DoTrapping(void);

  void DoOneStep(void);
  void Dump(void);

  void InitializePropagation(void);

  void PropagateOneStep(void);


  // Setters, getters, adders, etc.

  void AddToEnergyLoss(HepDouble eloss) { fEnergyLoss += eloss; }
  HepDouble   GetEnergyLoss()            { return fEnergyLoss; }
  HepInt      GetDiffusionStepInterval() { return fDiffusionStepInterval; }
  HepDouble   GetCharge()                { return fCharge; }
  HepInt      GetChargeSign()            { return fChargeSign; }
  void GetCurrentPosition(Hep3Vector *pos) { *pos = fCurrentPosition; }
  MJWaveformChargePoint *GetNextActiveChargePoint() 
    { return fNextActiveChargePoint; }
  MJWaveformChargePoint *GetNextChargePoint() 
    { return fNextChargePoint; }
  MJWaveformChargePoint *GetPreviousActiveChargePoint() 
    { return fPreviousActiveChargePoint; }
  MJWaveformChargePoint *GetPreviousChargePoint() 
    { return fPreviousChargePoint; }
  Hep3Vector  GetPreviousPosition()      { return fPreviousPosition; }
  Hep3Vector  GetOriginalPosition()      { return fOriginalPosition; }
  HepInt      GetNumberOfSteps()         { return fNumberOfSteps; }
  HepDouble   GetSigma()                 { return fSigma; }
  HepDouble   GetTimeStep()              {return fXtal->GetTimeStep(); }
  void GetVelocity(Hep3Vector *pos, Hep3Vector *vel)
  {
    *vel = fChargeSign > 0 ? fXtal->GetHoleVelocity(pos) : 
                       fXtal->GetElectronVelocity(pos);
  }
  void GetVelocity(Hep3Vector *vel)
  {
    if(fChargeSign > 0) 
      *vel = fXtal->GetHoleVelocity(&fCurrentPosition);
    else
      *vel = fXtal->GetElectronVelocity(&fCurrentPosition);
  }
  HepDouble   GetTotalTime()             { return fTotalTime; }
  HepInt      GetTrappingStepInterval()  { return fTrappingStepInterval; }
  HepBoolean  StillActive()              { return fActive; }

  void Deactivate() { fActive = false; }
  void SetCharge(HepDouble charge) { fCharge = charge; }
  void SetChargeSign(HepInt cs) { fChargeSign = cs; }
  void SetDiffusionStepInterval(HepInt interval) 
     { fDiffusionStepInterval = interval; }
  void SetNextActiveChargePoint(MJWaveformChargePoint *chp) 
     { fNextActiveChargePoint = chp; }
  void SetNextChargePoint(MJWaveformChargePoint *chp) 
     { fNextChargePoint = chp; }
  void SetOriginalPosition(Hep3Vector *pos) { fOriginalPosition = *pos; }
  void SetPreviousActiveChargePoint(MJWaveformChargePoint *chp) 
     { fPreviousActiveChargePoint = chp; }
  void SetPreviousChargePoint(MJWaveformChargePoint *chp) 
     { fPreviousChargePoint = chp; }
  void SetTrappingStepInterval(HepInt interval) 
     { fTrappingStepInterval = interval; }

  //protected members
protected:

  //private  members

private:

  HepBoolean fActive;

  HepDouble fCharge;

  HepInt fChargeSign;


  HepBoolean fDiffusionOn;

  HepInt fDiffusionStepInterval;



  Hep3Vector fCurrentPosition;
  Hep3Vector fPreviousPosition;
  Hep3Vector fOriginalPosition;


  HepDouble fEnergyLoss;

  HepInt fGridLocation[3];

  HepDouble fGridPointSize;

  MJWaveformChargePoint  *fNextActiveChargePoint;
  MJWaveformChargePoint  *fNextChargePoint;

  HepInt fNumberOfSteps;

  MJWaveformChargePoint  *fPreviousActiveChargePoint;
  MJWaveformChargePoint  *fPreviousChargePoint;

  HepDouble fSigma;

  HepDouble fTimeStep;

  HepDouble fTotalTime;

  HepBoolean fTrappingOn;
  HepInt fTrappingStepInterval;

  MJVWaveformCrystal *fXtal;

  void        RemoveFromActiveList(void); 
};
#endif

---