//
// ********************************************************************
// * 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.                                    *
// ********************************************************************
//
//
//
// 
// ------------------------------------------------------------
//      GEANT 4 class header file 
//
//
// R&D since 1996: Vladimir.Grichine@cern.ch
//
//
// 29.04.03 V.Grichine, corrections for cuts per region
// 28.05.01 V. Ivanchenko minor changes to provide ANSI -wall compilation 
// 22.09.00 V. Grichine and K.Assamagan new function GetEnergyTransfer(G4d,G4i)
// 12.07.00 V. Grichine GetFreePath and GetdEdx were added
// 24.11.97 V. Grichine corrections 

 
#ifndef G4PAIonisation_h
#define G4PAIonisation_h 1
 
#include "G4ios.hh"
#include "globals.hh"
#include "Randomize.hh"
#include "G4VPAIenergyLoss.hh"
#include "globals.hh"
#include "G4Track.hh"
#include "G4Step.hh"
#include "G4Electron.hh"
#include "G4PhysicsLogVector.hh"
#include "G4PhysicsLinearVector.hh"
#include "G4PhysicsFreeVector.hh"
#include "G4PhysicsVector.hh"
class G4LogicalVolume;
class G4MaterialCutsCouple;


class G4PAIonisation : public G4VPAIenergyLoss

{
  public:

     G4PAIonisation( G4LogicalVolume* lV,
                     const G4String& processName = "PAIonisation");

     G4PAIonisation( const G4String& materialName,
                     const G4String& processName = "PAIonisation");

    ~G4PAIonisation();

     G4bool IsApplicable(const G4ParticleDefinition&);

  private:

  // hide assignment operator

    G4PAIonisation & operator=(const G4PAIonisation &right);
    G4PAIonisation(const G4PAIonisation&);

  public:

  // post Step functions .......................................


    G4double GetConstraints(const G4DynamicParticle *aParticle,
                            G4Material *aMaterial);

     G4VParticleChange* PostStepDoIt( const G4Track& track,
                                      const G4Step& Step      ) ;


     //  void BuildLossTable(const G4ParticleDefinition& aParticleType);

     void BuildLambdaTable(const G4ParticleDefinition& aParticleType);

     void BuildPhysicsTable(const G4ParticleDefinition& aParticleType);

     void  BuildPAIonisationTable() ;


     virtual G4double ComputeMicroscopicCrossSection(
                            const G4ParticleDefinition& aParticleType,
                            G4double KineticEnergy,
                            G4double AtomicNumber);

  // Along step DoIt stuff

    G4double GetContinuousStepLimit(
                                    const G4Track& track,
                                    G4double previousStepSize,
                                    G4double currentMinimumStep,
                                    G4double& currentSafety) ;

    G4double GetMeanFreePath( const G4Track& track,
                               G4double previousStepSize,
                               G4ForceCondition* condition   ) ;

    G4double GetFreePath( G4double scaledTkin, G4double charge2 ) ;

    G4double GetdEdx( G4double scaledTkin, G4double charge2 ) ;

    G4VParticleChange* AlongStepDoIt(const G4Track& track ,const G4Step& Step) ;

    G4double GetLossWithFluct(G4double Step,
                              const G4DynamicParticle *aParticle,
                              G4Material *aMaterial) ;
    G4double GetAlongStepDelta(G4double Step,
                              const G4DynamicParticle *aParticle,
                              G4Material *aMaterial) ;

    G4double GetRandomEnergyTransfer( G4double scaledTkin ) ;
    G4double GetPostStepTransfer( G4double scaledTkin ) ;

    G4double GetEnergyTransfer( G4int iPlace, G4double position, G4int iTransfer  ) ;
    G4double GetdNdxCut( G4int iPlace, G4double cutTransfer) ;

  //    static                                   

    static G4double GetMaxKineticEnergy();
    static G4double GetMinKineticEnergy();
    static G4int    GetBinNumber();

  // Access to Sandia table coefficients

    G4int    GetSandiaIntervalNumber()    const {return fSandiaIntervalNumber;};
    G4double GetSandiaPhotoAbsCof(G4int, G4int) const;

    // Compute Sandia photoabsorption coefficient matrix
    void ComputeSandiaPhotoAbsCof() ;
 

  private:


    //  private data members
    G4LogicalVolume*  fLogicalVolume;
    size_t fMatIndex ;  // index of material, where dE/dx is calculated
    size_t fMatCutsIndex ;  // index of material, where dE/dx is calculated
    G4Material* fMaterial;
    G4MaterialCutsCouple* fMaterialCutsCouple;
    G4PhysicsTable* theMeanFreePathTable;

    // LowestKineticEnergy = lower limit of particle kinetic energy
    // HighestKineticEnergy = upper limit of particle kinetic energy
    // TotBin = number of bins in the energy ionisation loss table
    //

    static const G4double LowestKineticEnergy;
    static const G4double HighestKineticEnergy;
    static G4int TotBin;
    static G4PhysicsLogVector* fProtonEnergyVector ;
    G4PhysicsLogVector* fLambdaVector ;
    G4PhysicsLogVector* fdNdxCutVector ;
    G4PhysicsLogVector* fdEdxVector ;

    // cut in range

    G4double* CutInRange ;
    G4double* lastCutInRange ;

    // particles , cuts in kinetic energy

    const G4Electron* theElectron;
    const G4Proton* theProton;
    const G4AntiProton* theAntiProton;

    const std::vector<G4double>* DeltaCutInKineticEnergy ;

    G4double DeltaCutInKineticEnergyNow ;

    // Sandia Photo Absorption Coefficients

    G4double** fSandiaPhotoAbsCof ;
    G4int      fSandiaIntervalNumber ;


};

 
#include "G4PAIonisation.icc"
 
#endif