//
// ********************************************************************
// * License and Disclaimer                                           *
// *                                                                  *
// * The  Geant4 software  is  copyright of the Copyright Holders  of *
// * the Geant4 Collaboration.  It is provided  under  the terms  and *
// * conditions of the Geant4 Software License,  included in the file *
// * LICENSE and available at  http://cern.ch/geant4/license .  These *
// * include a list of copyright holders.                             *
// *                                                                  *
// * 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.  Please see the license in the file  LICENSE  and URL above *
// * for the full disclaimer and the limitation of liability.         *
// *                                                                  *
// * This  code  implementation is the result of  the  scientific and *
// * technical work of the GEANT4 collaboration.                      *
// * By using,  copying,  modifying or  distributing the software (or *
// * any work based  on the software)  you  agree  to acknowledge its *
// * use  in  resulting  scientific  publications,  and indicate your *
// * acceptance of all terms of the Geant4 Software license.          *
// ********************************************************************
//
// $Id: G4SandiaTable.cc 76289 2013-11-08 13:07:00Z gcosmo $

//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... ....oooOO0OOooo....
//
// 10.06.97 created. V. Grichine
// 18.11.98 simplified public interface; new methods for materials.  mma
// 31.01.01 redesign of ComputeMatSandiaMatrix().  mma
// 16.02.01 adapted for STL.  mma
// 22.02.01 GetsandiaCofForMaterial(energy) return 0 below lowest interval  mma  
// 03.04.01 fnulcof returned if energy < emin
// 10.07.01 Migration to STL. M. Verderi.
// 03.02.04 Update distructor V.Ivanchenko
// 05.03.04 New methods for old sorting algorithm for PAI model. V.Grichine
// 26.10.11 new scheme for G4Exception  (mma) 
// 22.05.13 preparation of material table without dynamical arrays. V. Grichine 
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... ....oooOO0OOooo....


#include "G4SandiaTable.hh"
#include "G4StaticSandiaData.hh"
#include "G4Material.hh"
#include "G4MaterialTable.hh"
// #include "G4MaterialCutsCouple.hh"
#include "G4PhysicalConstants.hh"
#include "G4SystemOfUnits.hh"

const G4double G4SandiaTable::funitc[5] = 
{
  CLHEP::keV,
  CLHEP::cm2*CLHEP::keV/CLHEP::g,     
  CLHEP::cm2*CLHEP::keV*CLHEP::keV/CLHEP::g,     
  CLHEP::cm2*CLHEP::keV*CLHEP::keV*CLHEP::keV/CLHEP::g,     
  CLHEP::cm2*CLHEP::keV*CLHEP::keV*CLHEP::keV*CLHEP::keV/CLHEP::g
};

const G4double G4SandiaTable::fnulcof[] = {0.0};

G4int G4SandiaTable::fCumulInterval[] = {0};
 
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... ....oooOO0OOooo....

G4SandiaTable::G4SandiaTable(G4Material* material)
  : fMaterial(material)
{
  fMatSandiaMatrix    = 0; 
  fMatSandiaMatrixPAI = 0;
  fPhotoAbsorptionCof = 0;

  fMatNbOfIntervals   = 0;
 
  fMaxInterval        = 0;
  fVerbose            = 0;  

  //build the CumulInterval array
  if(0 == fCumulInterval[0]) {
    fCumulInterval[0] = 1;

    for (G4int Z=1; Z<101; ++Z) {
      fCumulInterval[Z] = fCumulInterval[Z-1] + fNbOfIntervals[Z];
    }
  }
  
  fMaxInterval = 0;
  fSandiaCofPerAtom.resize(4,0.0);
  fLowerI1 = false;
  //compute macroscopic Sandia coefs for a material   
  ComputeMatSandiaMatrix(); // mma
}
							
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... ....oooOO0OOooo....

// Fake default constructor - sets only member data and allocates memory
//                            for usage restricted to object persistency

G4SandiaTable::G4SandiaTable(__void__&)
  : fMaterial(0),fMatSandiaMatrix(0),
    fMatSandiaMatrixPAI(0),fPhotoAbsorptionCof(0)
{
  fMaxInterval = 0;
  fMatNbOfIntervals = 0;
  fLowerI1 = false;
  fVerbose          = 0;  
  fSandiaCofPerAtom.resize(4,0.0);
}

//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... ....oooOO0OOooo....

G4SandiaTable::~G4SandiaTable()
{ 
  if(fMatSandiaMatrix) 
  {
    //fMatSandiaMatrix->clearAndDestroy();
    delete fMatSandiaMatrix;
  }
  if(fMatSandiaMatrixPAI) 
  {
    //fMatSandiaMatrixPAI->clearAndDestroy();
    delete fMatSandiaMatrixPAI;
  }
  if(fPhotoAbsorptionCof)
  {
    delete [] fPhotoAbsorptionCof;
  }
}

//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... ....oooOO0OOooo....

void
G4SandiaTable::GetSandiaCofPerAtom(G4int Z, G4double energy, 
				   std::vector<G4double>& coeff)
{
  assert(4 <= coeff.size());
  G4double Emin  = fSandiaTable[fCumulInterval[Z-1]][0]*keV;
  G4double Iopot = fIonizationPotentials[Z]*eV;
  if (Iopot > Emin) Emin = Iopot;
   
  G4int interval = fNbOfIntervals[Z] - 1;
  G4int row = fCumulInterval[Z-1] + interval;
  while ((interval>0) && (energy<fSandiaTable[row][0]*keV)) {
    --interval;
    row = fCumulInterval[Z-1] + interval;
  }
  if (energy >= Emin)
    {        
      G4double AoverAvo = Z*amu/fZtoAratio[Z];
         
      coeff[0]=AoverAvo*funitc[1]*fSandiaTable[row][1];     
      coeff[1]=AoverAvo*funitc[2]*fSandiaTable[row][2];     
      coeff[2]=AoverAvo*funitc[3]*fSandiaTable[row][3];     
      coeff[3]=AoverAvo*funitc[4]*fSandiaTable[row][4];
    }
  else 
    {
      coeff[0] = coeff[1] = coeff[2] = coeff[3] = 0.;
    }                
}

//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... ....oooOO0OOooo....
						 	
G4double G4SandiaTable::GetZtoA(G4int Z)
{
  assert (Z>0 && Z<101);
  return fZtoAratio[Z];
}

//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.... ....oooOO0OOooo....

void G4SandiaTable::ComputeMatSandiaMatrix()
{  
  //get list of elements
  const G4int NbElm = fMaterial->GetNumberOfElements();
  const G4ElementVector* ElementVector = fMaterial->GetElementVector();
  
  G4int* Z = new G4int[NbElm];               //Atomic number
   
  //determine the maximum number of energy-intervals for this material
  
  G4int MaxIntervals = 0;
  G4int elm;
    
  for ( elm = 0; elm < NbElm; elm++ ) 
  {
    Z[elm] = (G4int)(*ElementVector)[elm]->GetZ();
    MaxIntervals += fNbOfIntervals[Z[elm]];
  }  
     
  //copy the Energy bins in a tmp1 array
  //(take care of the Ionization Potential of each element)
  
  G4double* tmp1 = new G4double[MaxIntervals]; 
  G4double IonizationPot;
  G4int interval1 = 0;

  for ( elm = 0; elm < NbElm; elm++ ) 
  {
    IonizationPot = GetIonizationPot(Z[elm]);

    for (G4int row = fCumulInterval[Z[elm]-1]; row < fCumulInterval[Z[elm]]; row++)
    {
      tmp1[interval1++] = std::max(fSandiaTable[row][0]*keV,IonizationPot);
    }
  }   
        
  //sort the energies in strickly increasing values in a tmp2 array
  //(eliminate redondances)
  
  G4double* tmp2 = new G4double[MaxIntervals];
  G4double Emin;
  G4int interval2 = 0;
  
  do 
  {
    Emin = DBL_MAX;

    for ( G4int i1 = 0; i1 < MaxIntervals; i1++ ) 
    {
      if (tmp1[i1] < Emin) Emin = tmp1[i1];          //find the minimum
    }
    if (Emin < DBL_MAX) tmp2[interval2++] = Emin;
    //copy Emin in tmp2
    for ( G4int j1 = 0; j1 < MaxIntervals; j1++ ) 
    {
      if (tmp1[j1] <= Emin) tmp1[j1] = DBL_MAX;      //eliminate from tmp1	    
    }
  } while (Emin < DBL_MAX);
        	         	   	
  //create the sandia matrix for this material
    
  fMatSandiaMatrix = new G4OrderedTable();
  G4int interval;

  for (interval = 0; interval < interval2; interval++ ) 
  {
    fMatSandiaMatrix->push_back( new G4DataVector(5,0.) );
  }
  
  //ready to compute the Sandia coefs for the material
  
  const G4double* NbOfAtomsPerVolume = fMaterial->GetVecNbOfAtomsPerVolume();
  
  static const G4double prec = 1.e-03*eV;
  G4double coef, oldsum(0.), newsum(0.);
  fMatNbOfIntervals = 0;
         
  for ( interval = 0; interval < interval2; interval++ ) 
  {
    Emin = (*(*fMatSandiaMatrix)[fMatNbOfIntervals])[0] = tmp2[interval];

    for ( G4int k = 1; k < 5; k++ ) {
      (*(*fMatSandiaMatrix)[fMatNbOfIntervals])[k] = 0.;      
    }
    newsum = 0.;
      
    for ( elm = 0; elm < NbElm; elm++ ) 
    {    
      GetSandiaCofPerAtom(Z[elm], Emin+prec, fSandiaCofPerAtom);

      for ( G4int j = 1; j < 5; j++ ) 
      {
	coef = NbOfAtomsPerVolume[elm]*fSandiaCofPerAtom[j-1];
	(*(*fMatSandiaMatrix)[fMatNbOfIntervals])[j] += coef;
	newsum += std::fabs(coef);
      }						       
    }	      			      			      	 
    //check for null or redondant intervals
	 
    if (newsum != oldsum) { oldsum = newsum; fMatNbOfIntervals++;}
  }
  delete [] Z;
  delete [] tmp1;
  delete [] tmp2;

  //  fMaxInterval = fMatNbOfIntervals; // vmg 16.02.11

  if ( fVerbose > 0 && fMaterial->GetName() == "G4_Ar" )
  {
    G4cout<<"mma, G4SandiaTable::ComputeMatSandiaMatrix(), mat = "
	  <<fMaterial->GetName()<<G4endl;

    for( G4int i = 0; i < fMatNbOfIntervals; i++)
    {
      G4cout<<i<<"\t"<<GetSandiaCofForMaterial(i,0)/keV<<" keV \t"
	    <<this->GetSandiaCofForMaterial(i,1)
	    <<"\t"<<this->GetSandiaCofForMaterial(i,2)
	    <<"\t"<<this->GetSandiaCofForMaterial(i,3)
	    <<"\t"<<this->GetSandiaCofForMaterial(i,4)<<G4endl;
    }   
  }
}

///////////////////////////////////////////////////////////////////////////////////////
//
// Sandia matrix for PAI models based on vectors ...

void G4SandiaTable::ComputeMatSandiaMatrixPAI()
{  
  G4int MaxIntervals = 0;
  G4int elm, c, i, j, jj, k, k1, k2, c1, n1;    

  const G4int noElm = fMaterial->GetNumberOfElements();
  const G4ElementVector* ElementVector = fMaterial->GetElementVector();
  
  std::vector<G4int> Z(noElm);               //Atomic number

  for ( elm = 0; elm < noElm; elm++ )
  { 
    Z[elm] = (G4int)(*ElementVector)[elm]->GetZ();
    MaxIntervals += fNbOfIntervals[Z[elm]];
  }  
  fMaxInterval = MaxIntervals + 2;
  // fMaxInterval = MaxIntervals + 1;
  // fMaxInterval = MaxIntervals;

  if ( fVerbose > 0 )
  {
    G4cout<<"fMaxInterval = "<<fMaxInterval<<G4endl;
  } 

  G4DataVector fPhotoAbsorptionCof0(fMaxInterval);
  G4DataVector fPhotoAbsorptionCof1(fMaxInterval);
  G4DataVector fPhotoAbsorptionCof2(fMaxInterval);
  G4DataVector fPhotoAbsorptionCof3(fMaxInterval);
  G4DataVector fPhotoAbsorptionCof4(fMaxInterval);

  for( c = 0; c < fMaxInterval; c++ )   // just in case
  {
    fPhotoAbsorptionCof0[c] = 0.;
    fPhotoAbsorptionCof1[c] = 0.;
    fPhotoAbsorptionCof2[c] = 0.;
    fPhotoAbsorptionCof3[c] = 0.;
    fPhotoAbsorptionCof4[c] = 0.;
  }
  c = 1;

  for(i = 0; i < noElm; i++)
  {
    G4double I1 = fIonizationPotentials[Z[i]]*keV;  // I1 in keV
    n1          = 1;                                    
 
    for( j = 1; j < Z[i]; j++ )  n1 += fNbOfIntervals[j];
    
    G4int n2 = n1 + fNbOfIntervals[Z[i]];
    
    for( k1 = n1; k1 < n2; k1++ )
    {
      if( I1  > fSandiaTable[k1][0] )
      {
	 continue;    // no ionization for energies smaller than I1 (first
      }		       // ionisation potential)		     
      break;
    }
    G4int flag = 0;
    
    for( c1 = 1; c1 < c; c1++ )
    {
      if( fPhotoAbsorptionCof0[c1] == I1 ) // this value already has existed
      {
	flag = 1;                      
	break;                         
      }
    }
    if(flag == 0)
    {
      fPhotoAbsorptionCof0[c] = I1;
      c++;
    }
    for( k2 = k1; k2 < n2; k2++ )
    {
      flag = 0;

      for( c1 = 1; c1 < c; c1++ )
      {
        if( fPhotoAbsorptionCof0[c1] == fSandiaTable[k2][0] )
        {
	  flag = 1;
 	  break;
        }
      }
      if(flag == 0)
      {
        fPhotoAbsorptionCof0[c] = fSandiaTable[k2][0];
	c++;
      }
    }       
  }   // end for(i)
  // sort out

  for( i = 1; i < c; i++ ) 
  {
    for( j = i + 1; j < c;  j++ )
    {
      if( fPhotoAbsorptionCof0[i] > fPhotoAbsorptionCof0[j] ) 
      {
        G4double tmp = fPhotoAbsorptionCof0[i];
	fPhotoAbsorptionCof0[i] = fPhotoAbsorptionCof0[j];
	fPhotoAbsorptionCof0[j] = tmp;
      }
    }
    if ( fVerbose > 0 && fMaterial->GetName() == "G4_Ar" )
    {
      G4cout<<i<<"\t energy = "<<fPhotoAbsorptionCof0[i]<<G4endl;
    }
  } 
  fMaxInterval = c;
 
  const G4double* fractionW = fMaterial->GetFractionVector();

  if ( fVerbose > 0 && fMaterial->GetName() == "G4_Ar" )
  {
    for( i = 0; i < noElm; i++ )  G4cout<<i<<" = elN, fraction = "<<fractionW[i]<<G4endl;
  }      
   
  for( i = 0; i < noElm; i++ )
  {
    n1 = 1;
    G4double I1 = fIonizationPotentials[Z[i]]*keV;

    for( j = 1; j < Z[i]; j++ )  n1 += fNbOfIntervals[j];
	
    G4int n2 = n1 + fNbOfIntervals[Z[i]] - 1;

    for(k = n1; k < n2; k++)
    {
      G4double B1 = fSandiaTable[k][0];
      G4double B2 = fSandiaTable[k+1][0];

      for(G4int q = 1; q < fMaxInterval-1; q++)
      {
	G4double E1 = fPhotoAbsorptionCof0[q];
	G4double E2 = fPhotoAbsorptionCof0[q+1];

        if ( fVerbose > 0  )
        {
          G4cout<<"k = "<<k<<", q = "<<q<<", B1 = "<<B1<<", B2 = "<<B2
		<<", E1 = "<<E1<<", E2 = "<<E2<<G4endl;
        }      
	if( B1 > E1 || B2 < E2 || E1 < I1 )  
	{
          if ( fVerbose > 0  )
          {
            G4cout<<"continue for: B1 = "<<B1<<", B2 = "<<B2<<", E1 = "
		  <<E1<<", E2 = "<<E2<<G4endl;
          }      
          continue;
	}		
	fPhotoAbsorptionCof1[q] += fSandiaTable[k][1]*fractionW[i];
	fPhotoAbsorptionCof2[q] += fSandiaTable[k][2]*fractionW[i];
	fPhotoAbsorptionCof3[q] += fSandiaTable[k][3]*fractionW[i];
	fPhotoAbsorptionCof4[q] += fSandiaTable[k][4]*fractionW[i];
      }  
    }   
    // Last interval

    fPhotoAbsorptionCof1[fMaxInterval-1] += fSandiaTable[k][1]*fractionW[i];
    fPhotoAbsorptionCof2[fMaxInterval-1] += fSandiaTable[k][2]*fractionW[i];
    fPhotoAbsorptionCof3[fMaxInterval-1] += fSandiaTable[k][3]*fractionW[i];
    fPhotoAbsorptionCof4[fMaxInterval-1] += fSandiaTable[k][4]*fractionW[i];
  }     // for(i)  
  c = 0;     // Deleting of first intervals where all coefficients = 0

  do                        
  {
    c++;

    if( fPhotoAbsorptionCof1[c] != 0.0 ||
	fPhotoAbsorptionCof2[c] != 0.0 ||
        fPhotoAbsorptionCof3[c] != 0.0 || 
	fPhotoAbsorptionCof4[c] != 0.0     )  continue;

    if ( fVerbose > 0 )
    {
      G4cout<<c<<" = number with zero cofs"<<G4endl;
    }      
    for( jj = 2; jj < fMaxInterval; jj++ )
    {
      fPhotoAbsorptionCof0[jj-1] = fPhotoAbsorptionCof0[jj];
      fPhotoAbsorptionCof1[jj-1] = fPhotoAbsorptionCof1[jj];
      fPhotoAbsorptionCof2[jj-1] = fPhotoAbsorptionCof2[jj];
      fPhotoAbsorptionCof3[jj-1] = fPhotoAbsorptionCof3[jj];
      fPhotoAbsorptionCof4[jj-1] = fPhotoAbsorptionCof4[jj];
    }
    fMaxInterval--;
    // c--;
  }
  while( c < fMaxInterval - 1 ); // was <

  if( fPhotoAbsorptionCof0[fMaxInterval-1] == 0.0 ) fMaxInterval--; 
  	
  // create the sandia matrix for this material
  
  fMatSandiaMatrixPAI = new G4OrderedTable();

  G4double density = fMaterial->GetDensity();

  for (i = 0; i < fMaxInterval; i++) // -> G4units
  {
    fPhotoAbsorptionCof0[i+1] *= funitc[0];
    fPhotoAbsorptionCof1[i+1] *= funitc[1]*density;
    fPhotoAbsorptionCof2[i+1] *= funitc[2]*density;
    fPhotoAbsorptionCof3[i+1] *= funitc[3]*density;
    fPhotoAbsorptionCof4[i+1] *= funitc[4]*density;
  }
  if(fLowerI1)
  {
    if( fMaterial->GetName() == "G4_WATER")
    {
      fMaxInterval += fH2OlowerInt;

      for (i = 0; i < fMaxInterval; i++) // init vector table
      {
        fMatSandiaMatrixPAI->push_back( new G4DataVector(5,0.) );
      } 	         	
      for (i = 0; i < fH2OlowerInt; i++)
      {
        (*(*fMatSandiaMatrixPAI)[i])[0] = fH2OlowerI1[i][0];
        (*(*fMatSandiaMatrixPAI)[i])[1] = fH2OlowerI1[i][1]; // *density;
        (*(*fMatSandiaMatrixPAI)[i])[2] = fH2OlowerI1[i][2]; // *density;
        (*(*fMatSandiaMatrixPAI)[i])[3] = fH2OlowerI1[i][3]; // *density;
        (*(*fMatSandiaMatrixPAI)[i])[4] = fH2OlowerI1[i][4]; // *density;
      }
      for (i = fH2OlowerInt; i < fMaxInterval; i++)
      {
        (*(*fMatSandiaMatrixPAI)[i])[0] = fPhotoAbsorptionCof0[i+1-fH2OlowerInt];
        (*(*fMatSandiaMatrixPAI)[i])[1] = fPhotoAbsorptionCof1[i+1-fH2OlowerInt]; // *density;
        (*(*fMatSandiaMatrixPAI)[i])[2] = fPhotoAbsorptionCof2[i+1-fH2OlowerInt]; // *density;
        (*(*fMatSandiaMatrixPAI)[i])[3] = fPhotoAbsorptionCof3[i+1-fH2OlowerInt]; // *density;
        (*(*fMatSandiaMatrixPAI)[i])[4] = fPhotoAbsorptionCof4[i+1-fH2OlowerInt]; // *density;
      }
    }
  }
  else
  { 
    for (i = 0; i < fMaxInterval; i++) // init vector table
    {
      fMatSandiaMatrixPAI->push_back( new G4DataVector(5,0.) );
    } 	         	
    for (i = 0; i < fMaxInterval; i++)
    {
      (*(*fMatSandiaMatrixPAI)[i])[0] = fPhotoAbsorptionCof0[i+1];
      (*(*fMatSandiaMatrixPAI)[i])[1] = fPhotoAbsorptionCof1[i+1]; // *density;
      (*(*fMatSandiaMatrixPAI)[i])[2] = fPhotoAbsorptionCof2[i+1]; // *density;
      (*(*fMatSandiaMatrixPAI)[i])[3] = fPhotoAbsorptionCof3[i+1]; // *density;
      (*(*fMatSandiaMatrixPAI)[i])[4] = fPhotoAbsorptionCof4[i+1]; // *density;
    }
  }
  // fMaxInterval--; // to avoid duplicate at 500 keV or extra zeros in last interval

  if ( fVerbose > 0  )
  {
    G4cout<<"vmg, G4SandiaTable::ComputeMatSandiaMatrixPAI(), mat = "
	  <<fMaterial->GetName()<<G4endl;

    for( i = 0; i < fMaxInterval; i++)
    {
      G4cout<<i<<"\t"<<GetSandiaMatTablePAI(i,0)/keV<<" keV \t"
	    <<this->GetSandiaMatTablePAI(i,1)
	    <<"\t"<<this->GetSandiaMatTablePAI(i,2)
	    <<"\t"<<this->GetSandiaMatTablePAI(i,3)
	    <<"\t"<<this->GetSandiaMatTablePAI(i,4)<<G4endl;
    }   
  }
  return;
}

//////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////
//
// Methods for PAI model only
//

G4SandiaTable::G4SandiaTable(G4int matIndex)
{ 
  fMaterial           = 0;
  fMatNbOfIntervals   = 0;
  fMatSandiaMatrix    = 0; 
  fMatSandiaMatrixPAI = 0;
  fPhotoAbsorptionCof = 0;
 
  fMaxInterval        = 0;
  fVerbose            = 0;  

  fSandiaCofPerAtom.resize(4,0.0);

  const G4MaterialTable* theMaterialTable = G4Material::GetMaterialTable();
  G4int numberOfMat = G4Material::GetNumberOfMaterials();

  if ( matIndex >= 0 && matIndex < numberOfMat)
    {
      fMaterial = (*theMaterialTable)[matIndex];
      // ComputeMatTable();
    }
  else
    {
      G4Exception("G4SandiaTable::G4SandiaTable(G4int matIndex)", "mat401",
       FatalException, "wrong matIndex");
    }
}

/////////////////////////////////////////////////////////////////////////////
        
G4SandiaTable::G4SandiaTable()
{ 
  fMaterial           = 0;
  fMatNbOfIntervals   = 0;
  fMatSandiaMatrix    = 0; 
  fMatSandiaMatrixPAI = 0;
  fPhotoAbsorptionCof = 0;
 
  fMaxInterval        = 0;
  fVerbose            = 0;  
  fLowerI1 = false;

  fSandiaCofPerAtom.resize(4,0.0);
}

////////////////////////////////////////////////////////////////////
  
void G4SandiaTable::Initialize(G4Material* mat)
{
  fMaterial = mat;
  ComputeMatSandiaMatrixPAI();
}

/////////////////////////////////////////////////////////////////////

/*
void G4SandiaTable::Initialize(G4MaterialCutsCouple* matcc)
{
  fMaterial = matcc->GetMaterial();
  ComputeMatSandiaMatrixPAI();
}
*/

///////////////////////////////////////////////////////////////////////

void G4SandiaTable::Initialize(G4int matIndex)
{
  const G4MaterialTable* theMaterialTable = G4Material::GetMaterialTable();
  G4int numberOfMat = G4Material::GetNumberOfMaterials();

  if ( matIndex >= 0 && matIndex < numberOfMat )
  {
    fMaterial = (*theMaterialTable)[matIndex];
    ComputeMatTable();
  }
  else
  {
    G4Exception("G4SandiaTable::Initialize(G4int matIndex)", "mat401",
    FatalException, "wrong matIndex");
  }
}

//////////////////////////////////////////////////////////////////////////////..

G4int G4SandiaTable::GetMaxInterval() const { 
  return fMaxInterval;
}

/////////////////////////////////////////////////////////////////////////////////..

G4double** G4SandiaTable::GetPointerToCof() 
{ 
  if(!fPhotoAbsorptionCof) { ComputeMatTable(); }
  return fPhotoAbsorptionCof;
}

//////////////////////////////////////////////////////////////////////////////..

void G4SandiaTable::SandiaSwap( G4double** da ,
				G4int i,
				G4int j )
{
  G4double tmp = da[i][0] ;
  da[i][0] = da[j][0] ;
  da[j][0] = tmp ;
}

/////////////////////////////////////////////////////////////////////////////////..

G4double G4SandiaTable::GetPhotoAbsorpCof(G4int i, G4int j) const
{
  return  fPhotoAbsorptionCof[i][j]*funitc[j];
}

//////////////////////////////////////////////////////////////////////////////////..
//
// Bubble sorting of left energy interval in SandiaTable in ascening order
//

void
G4SandiaTable::SandiaSort(G4double** da, G4int sz)
{
  for(G4int i = 1;i < sz; i++ ) 
   {
     for(G4int j = i + 1;j < sz; j++ )
     {
       if(da[i][0] > da[j][0])   SandiaSwap(da,i,j);      
     }
   }
}

///////////////////////////////////////////////////////////////////////////////////////..
//
//  SandiaIntervals 
//

G4int G4SandiaTable::SandiaIntervals(G4int Z[], G4int el )
{
  G4int c,  i, flag = 0, n1 = 1;
  G4int j, c1, k1, k2;
  G4double I1;
  fMaxInterval = 0;

  for( i = 0; i < el; i++ )  fMaxInterval += fNbOfIntervals[ Z[i] ]; 

  fMaxInterval += 2;

  if( fVerbose > 0 ) {
    G4cout<<"begin sanInt, fMaxInterval = "<<fMaxInterval<<G4endl;
  }

  fPhotoAbsorptionCof = new G4double* [fMaxInterval];

  for( i = 0; i < fMaxInterval; i++ ) {
    fPhotoAbsorptionCof[i] = new G4double[5];
  }
  //  for(c = 0; c < fIntervalLimit; c++)   // just in case

  for( c = 0; c < fMaxInterval; c++ ) { fPhotoAbsorptionCof[c][0] = 0.; }
  
  c = 1;

  for( i = 0; i < el; i++ )
  {
    I1 = fIonizationPotentials[ Z[i] ]*keV;  // First ionization
    n1 = 1;                                  // potential in keV

    for( j = 1; j < Z[i]; j++ )  n1 += fNbOfIntervals[j];
    
    G4int n2 = n1 + fNbOfIntervals[Z[i]];
    
    for( k1 = n1; k1 < n2; k1++ )
    {
      if( I1  > fSandiaTable[k1][0] )
      {
	 continue;    // no ionization for energies smaller than I1 (first
      }		       // ionisation potential)		     
      break;
    }
    flag = 0;
    
    for( c1 = 1; c1 < c; c1++ )
    {
      if( fPhotoAbsorptionCof[c1][0] == I1 ) // this value already has existed
      {
	flag = 1;                      
	break;                         
      }
    }
    if( flag == 0 )
    {
      fPhotoAbsorptionCof[c][0] = I1;
      c++;
    }
    for( k2 = k1; k2 < n2; k2++ )
    {
      flag = 0;

      for( c1 = 1; c1 < c; c1++ )
      {
        if( fPhotoAbsorptionCof[c1][0] == fSandiaTable[k2][0] )
        {
	  flag = 1;
 	  break;
        }
      }
      if( flag == 0 )
      {
        fPhotoAbsorptionCof[c][0] = fSandiaTable[k2][0];
	if( fVerbose > 0 ) {
	  G4cout<<"sanInt, c = "<<c<<", E_c = "<<fPhotoAbsorptionCof[c][0]
		<<G4endl;
	}
	c++;
      }
    }       
  }   // end for(i)
  
  SandiaSort(fPhotoAbsorptionCof,c);
  fMaxInterval = c;
  if( fVerbose > 0 ) {
    G4cout<<"end SanInt, fMaxInterval = "<<fMaxInterval<<G4endl;
  }
  return c;
}   

////////////////////////////////////////////////////////////////////////////..
//
//  SandiaMixing
//

G4int
G4SandiaTable::SandiaMixing(         G4int Z[],
			       const G4double fractionW[],
			             G4int el,
			             G4int mi     )
{
  G4int i, j, n1, k, c=1, jj, kk;
  G4double I1, B1, B2, E1, E2;
   
  for( i = 0; i < mi; i++ )
  {
    for( j = 1; j < 5; j++ ) fPhotoAbsorptionCof[i][j] = 0.;
  }
  for( i = 0; i < el; i++ )
  {
    n1 = 1;
    I1 = fIonizationPotentials[Z[i]]*keV;

    for( j = 1; j < Z[i]; j++ )   n1 += fNbOfIntervals[j];
      
    G4int n2 = n1 + fNbOfIntervals[Z[i]] - 1;

    for( k = n1; k < n2; k++ )
    {
      B1 = fSandiaTable[k][0];
      B2 = fSandiaTable[k+1][0];

      for( c = 1; c < mi-1; c++ )
      {
        E1 = fPhotoAbsorptionCof[c][0];
        E2 = fPhotoAbsorptionCof[c+1][0];

        if( B1 > E1 || B2 < E2 || E1 < I1 )   continue;
	    
	for( j = 1; j < 5; j++ ) 
	{
          fPhotoAbsorptionCof[c][j] += fSandiaTable[k][j]*fractionW[i];
          if( fVerbose > 0 )
	  {
	    G4cout<<"c="<<c<<"; j="<<j<<"; fST="<<fSandiaTable[k][j]
		  <<"; frW="<<fractionW[i]<<G4endl;
	  }
	}	    
      }  
    }   
    for( j = 1; j < 5; j++ )   // Last interval
    {
      fPhotoAbsorptionCof[mi-1][j] += fSandiaTable[k][j]*fractionW[i];
      if( fVerbose > 0 )
      {
	G4cout<<"mi-1="<<mi-1<<"; j="<<j<<"; fST="<<fSandiaTable[k][j]
	      <<"; frW="<<fractionW[i]<<G4endl;
      }
    }
  }     // for(i)
  c = 0;     // Deleting of first intervals where all coefficients = 0

  do                        
  {
    c++;

    if( fPhotoAbsorptionCof[c][1] != 0.0 ||
	fPhotoAbsorptionCof[c][2] != 0.0 ||
        fPhotoAbsorptionCof[c][3] != 0.0 || 
	fPhotoAbsorptionCof[c][4] != 0.0     )  continue;
       
    for( jj = 2; jj < mi; jj++ )
    {
      for( kk = 0; kk < 5; kk++ ) {
	fPhotoAbsorptionCof[jj-1][kk] = fPhotoAbsorptionCof[jj][kk];
      }
    }
    mi--;
    c--;
  }
  while( c < mi - 1 );

  if( fVerbose > 0 ) G4cout<<"end SanMix, mi = "<<mi<<G4endl;
    
  return mi;
}  

////////////////////////////////////////////////////////////////////////////..

G4int G4SandiaTable::GetMatNbOfIntervals()  
{
  return fMatNbOfIntervals;
}

//////////////////////////////////////////////////////////////////////////////..

G4int G4SandiaTable::GetNbOfIntervals(G4int Z)
{
  assert (Z>0 && Z<101);  
  return fNbOfIntervals[Z];
}

//////////////////////////////////////////////////////////////////////////////..

G4double
G4SandiaTable::GetSandiaPerAtom(G4int Z, G4int interval, G4int j)
{
  assert (Z>0 && Z<101 && interval>=0 && interval<fNbOfIntervals[Z]
	  && j>=0 && j<5);

  G4int row = fCumulInterval[Z-1] + interval;
  G4double x = fSandiaTable[row][0]*CLHEP::keV;
  if (j > 0) {
    x = Z*CLHEP::amu/fZtoAratio[Z]*fSandiaTable[row][j]*funitc[j];     
  }
  return x;
}

/////////////////////////////////////////////////////////////////////////////////..

G4double  
G4SandiaTable::GetSandiaCofForMaterial(G4int interval, G4int j)    
{
  assert (interval>=0 && interval<fMatNbOfIntervals && j>=0 && j<5);
  return ((*(*fMatSandiaMatrix)[interval])[j]); 
}

/////////////////////////////////////////////////////////////////////////////////..

const G4double* 
G4SandiaTable::GetSandiaCofForMaterial(G4double energy)
{
  const G4double* x = fnulcof;
  if (energy >= (*(*fMatSandiaMatrix)[0])[0]) {
   
    G4int interval = fMatNbOfIntervals - 1;
    while ((interval>0)&&(energy<(*(*fMatSandiaMatrix)[interval])[0])) 
      {interval--;} 
    x = &((*(*fMatSandiaMatrix)[interval])[1]);
  }
  return x;
}

/////////////////////////////////////////////////////////////////////////////////..

G4double  
G4SandiaTable::GetSandiaMatTable(G4int interval, G4int j) 
{
  assert (interval >= 0 && interval < fMaxInterval && j >= 0 && j < 5 );
  return ((*(*fMatSandiaMatrix)[interval])[j])*funitc[j]; 
}

//////////////////////////////////////////////////////////////////////////////////..

G4double  
G4SandiaTable::GetSandiaCofForMaterialPAI(G4int interval, G4int j)    
{
  assert (interval>=0 && interval<fMatNbOfIntervals && j>=0 && j<5);
  if(!fMatSandiaMatrixPAI) ComputeMatSandiaMatrixPAI();
  return ((*(*fMatSandiaMatrixPAI)[interval])[j]); 
}

////////////////////////////////////////////////////////////////////////////////..

const G4double* 
G4SandiaTable::GetSandiaCofForMaterialPAI(G4double energy)
{
  if(!fMatSandiaMatrixPAI) ComputeMatSandiaMatrixPAI();
  const G4double* x = fnulcof;
  if (energy >= (*(*fMatSandiaMatrixPAI)[0])[0]) {
   
    G4int interval = fMatNbOfIntervals - 1;
    while ((interval>0)&&(energy<(*(*fMatSandiaMatrixPAI)[interval])[0])) 
      {interval--;} 
    x = &((*(*fMatSandiaMatrixPAI)[interval])[1]);
  }
  return x;
}

/////////////////////////////////////////////////////////////////////////////////..

G4double  
G4SandiaTable::GetSandiaMatTablePAI(G4int interval, G4int j) 
{
  assert (interval >= 0 && interval < fMaxInterval && j >= 0 && j < 5 );
  if(!fMatSandiaMatrixPAI) { ComputeMatSandiaMatrixPAI(); }
  return ((*(*fMatSandiaMatrixPAI)[interval])[j]); // *funitc[j];-> to method 
}

////////////////////////////////////////////////////////////////////////////////////..

G4double
G4SandiaTable::GetIonizationPot(G4int Z)
{
  assert (Z>0 && Z<101);
  return fIonizationPotentials[Z]*CLHEP::eV;
}

/////////////////////////////////////////////////////////////////////////////////..

G4OrderedTable*  
G4SandiaTable::GetSandiaMatrixPAI()
{
  if(!fMatSandiaMatrixPAI) { ComputeMatSandiaMatrixPAI(); }
  return fMatSandiaMatrixPAI;
}

//////////////////////////////////////////////////////////////////////////////////..
//
//  Sandia interval and mixing calculations for materialCutsCouple constructor 
//

void G4SandiaTable::ComputeMatTable()
{
  G4int MaxIntervals = 0;
  G4int elm, c, i, j, jj, k, kk, k1, k2, c1, n1;    

  const G4int noElm = fMaterial->GetNumberOfElements();
  const G4ElementVector* ElementVector = fMaterial->GetElementVector();  
  G4int* Z = new G4int[noElm];               //Atomic number

  for (elm = 0; elm<noElm; elm++)
  { 
    Z[elm] = (G4int)(*ElementVector)[elm]->GetZ();
    MaxIntervals += fNbOfIntervals[Z[elm]];
  }  
  fMaxInterval = 0;

  for(i = 0; i < noElm; i++)  fMaxInterval += fNbOfIntervals[Z[i]]; 
  
  fMaxInterval += 2;

  //  G4cout<<"fMaxInterval = "<<fMaxInterval<<G4endl;

  fPhotoAbsorptionCof = new G4double* [fMaxInterval];

  for(i = 0; i < fMaxInterval; i++)  
  {
     fPhotoAbsorptionCof[i] = new G4double[5];
  }

  //  for(c = 0; c < fIntervalLimit; c++)   // just in case

  for(c = 0; c < fMaxInterval; c++)   // just in case
  {
     fPhotoAbsorptionCof[c][0] = 0.;
  }
  c = 1;

  for(i = 0; i < noElm; i++)
  {
    G4double I1 = fIonizationPotentials[Z[i]]*keV;  // First ionization
    n1 = 1;                                     // potential in keV
 
    for(j = 1; j < Z[i]; j++)
    {
      n1 += fNbOfIntervals[j];
    }
    G4int n2 = n1 + fNbOfIntervals[Z[i]];
    
    for(k1 = n1; k1 < n2; k1++)
    {
      if(I1  > fSandiaTable[k1][0])
      {
	 continue;    // no ionization for energies smaller than I1 (first
      }		       // ionisation potential)		     
      break;
    }
    G4int flag = 0;
    
    for(c1 = 1; c1 < c; c1++)
    {
      if(fPhotoAbsorptionCof[c1][0] == I1) // this value already has existed
      {
	flag = 1;                      
	break;                         
      }
    }
    if(flag == 0)
    {
      fPhotoAbsorptionCof[c][0] = I1;
      c++;
    }
    for(k2 = k1; k2 < n2; k2++)
    {
      flag = 0;

      for(c1 = 1; c1 < c; c1++)
      {
        if(fPhotoAbsorptionCof[c1][0] == fSandiaTable[k2][0])
        {
	  flag = 1;
 	  break;
        }
      }
      if(flag == 0)
      {
        fPhotoAbsorptionCof[c][0] = fSandiaTable[k2][0];
	c++;
      }
    }       
  }   // end for(i)
  
  SandiaSort(fPhotoAbsorptionCof,c);
  fMaxInterval = c;
 
  const G4double* fractionW = fMaterial->GetFractionVector();
   
  for(i = 0; i < fMaxInterval; i++)
  {
      for(j = 1; j < 5; j++) fPhotoAbsorptionCof[i][j] = 0.;
  }
  for(i = 0; i < noElm; i++)
  {
      n1 = 1;
      G4double I1 = fIonizationPotentials[Z[i]]*keV;

      for(j = 1; j < Z[i]; j++)
      {
         n1 += fNbOfIntervals[j];
      }
      G4int n2 = n1 + fNbOfIntervals[Z[i]] - 1;

      for(k = n1; k < n2; k++)
      {
         G4double B1 = fSandiaTable[k][0];
         G4double B2 = fSandiaTable[k+1][0];
         for(G4int q = 1; q < fMaxInterval-1; q++)
         {
            G4double E1 = fPhotoAbsorptionCof[q][0];
            G4double E2 = fPhotoAbsorptionCof[q+1][0];
            if(B1 > E1 || B2 < E2 || E1 < I1)
	    {
	       continue;
	    }
	    for(j = 1; j < 5; j++)
  	    {
               fPhotoAbsorptionCof[q][j] += fSandiaTable[k][j]*fractionW[i];
 	    }
	  }  
       }   
       for(j = 1; j < 5; j++)   // Last interval
       {
	 fPhotoAbsorptionCof[fMaxInterval-1][j] += 
	   fSandiaTable[k][j]*fractionW[i];
       }
  }     // for(i)

  c = 0; // Deleting of first intervals where all coefficients = 0

  do                        
  {
    c++;

    if( fPhotoAbsorptionCof[c][1] != 0.0 ||
	fPhotoAbsorptionCof[c][2] != 0.0 ||
	fPhotoAbsorptionCof[c][3] != 0.0 || 
	fPhotoAbsorptionCof[c][4] != 0.0     )  continue;
       
    for(jj = 2; jj < fMaxInterval; jj++)
    {
      for(kk = 0; kk < 5; kk++)
      {
	     fPhotoAbsorptionCof[jj-1][kk]= fPhotoAbsorptionCof[jj][kk];
      }
    }
    fMaxInterval--;
    c--;
  }
  while( c < fMaxInterval - 1 );
  	
  // create the sandia matrix for this material

  fMaxInterval--;  // vmg 20.11.10
    
  fMatSandiaMatrix = new G4OrderedTable();
 
  for (i = 0; i < fMaxInterval; i++)
  {
     fMatSandiaMatrix->push_back(new G4DataVector(5,0.));
  }	         	
  for ( i = 0; i < fMaxInterval; i++ )
  {
    for( j = 0; j < 5; j++ )
    {
      (*(*fMatSandiaMatrix)[i])[j] = fPhotoAbsorptionCof[i+1][j];
    }     
  }
  fMatNbOfIntervals = fMaxInterval; 
	         	    
  if ( fVerbose > 0 )
  {
    G4cout<<"vmg, G4SandiaTable::ComputeMatTable(), mat = "
	  <<fMaterial->GetName()<<G4endl;

    for ( i = 0; i < fMaxInterval; i++ )
    {
      // G4cout<<i<<"\t"<<(*(*fMatSandiaMatrix)[i])[0]<<" keV \t"
      // <<(*(*fMatSandiaMatrix)[i])[1]
      //       <<"\t"<<(*(*fMatSandiaMatrix)[i])[2]<<"\t"
      // <<(*(*fMatSandiaMatrix)[i])[3]
      //   <<"\t"<<(*(*fMatSandiaMatrix)[i])[4]<<G4endl;

      G4cout<<i<<"\t"<<GetSandiaCofForMaterial(i,0)/keV
	    <<" keV \t"<<this->GetSandiaCofForMaterial(i,1)
	    <<"\t"<<this->GetSandiaCofForMaterial(i,2)
	    <<"\t"<<this->GetSandiaCofForMaterial(i,3)
	    <<"\t"<<this->GetSandiaCofForMaterial(i,4)<<G4endl;
    }
  }	         	    
  delete [] Z;
  return;
}  

//
//
////////////////////////////////////////////////////////////////////////////////////////..