ROOT logo
///////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                           //
//     DIGMAPS                                                                               //
//                                                                                           //
//    Main Class of DIGMAPS                                                                  //
// Contains pointers to all other classes and to the root tree                               //
//   units are all in micrometer.                                                            //
//                                                                                           //
//     contains:                                                                             //
//    - Run() function (loop on all configurations)                                          //
//    - ActionPlot() function (plot a configuration)                                         //
//    - RunConfiguration() loop on all events for a given configuration                      //
//                                                                                           //
///////////////////////////////////////////////////////////////////////////////////////////////
#include <digmaps.h>
#include <TStopwatch.h>
#include <TROOT.h> // for gROOT object
#include <TMath.h>
#include <TMatrixD.h>
#include <TCanvas.h>
#include <TGraph.h>
#include <TAxis.h>
#include <TRandom3.h>
#include <TFile.h>
#include <TTree.h>
#include <TBranch.h>
#include <TClonesArray.h>

#include "digaction.h"
#include "digadc.h"
#include "digbeam.h"
#include "digtransport.h"
#include "digevent.h"
#include "diginitialize.h"
#include "digparticle.h"
#include "digcluster.h"
#include "digplane.h"
#include "dighistograms.h"

extern Int_t GlobalSeed;

//==============================================================================
ClassImp(DIGMAPS)
DIGMAPS::DIGMAPS()  
  : TNamed("DIGMAPS","DIGMAPS title")
{
  //
  // default constructor
  //
}
//______________________________________________________________________________
//  

DIGMAPS::DIGMAPS(char *name, char *title, TString aCP, TString aCFN,  TString outp, TString outf, TString action )  : TNamed(name,title)
{
  timer1.Start();
  time_t seconds;
  seconds = time(NULL); 
  gRandom->SetSeed(seconds);
  GlobalSeed=seconds;

  SetConfigPathAndFileName(aCP,aCFN); 
  SetIsOutputfile(1);
  SetOutputPathAndFileName(outp,outf) ;
  SetfAction(action);
  std::cout<<"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"<<endl;
  std::cout<<"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"<<endl;
  std::cout<<"++                                                           ++"<<endl;
  std::cout<<"++                                                           ++"<<endl;
  std::cout<<"++                   WELCOME to DIGMAPS                      ++"<<endl;
  std::cout<<"++                                                           ++"<<endl;
  std::cout<<"++                                                           ++"<<endl;
  std::cout<<"++         Version: 1.01    Date: March 29th 2011            ++"<<endl;
  std::cout<<"++         Author: Auguste Besson abesson@in2p3.fr           ++"<<endl;
  std::cout<<"++                   (WITH OUTPUT FILE)                      ++"<<endl;
  std::cout<<"++                                                           ++"<<endl;
  std::cout<<"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"<<endl;
  std::cout<<"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"<<endl;
  fDIGPlaneArray=0;
  fDIGADCArray=0;
  fDIGBeamArray=0;
  fDIGTransportArray=0;
  ffile=0;
  ftree=0;
  fDIGInitialize=0;
  fdigbeam=0;
  fdigplane=0;
  fdigadc=0;

  Run();
  timer1.Stop();
  cout<<" REAL TIME = "<<timer1.RealTime()<<" ; CPU TIME = "<<timer1.CpuTime()<<endl;

}
//______________________________________________________________________________
//  

DIGMAPS::DIGMAPS(char *name, char *title, TString aCP, TString aCFN , TString action )  : TNamed(name,title)
{
  timer1.Start();

  time_t seconds;
  seconds = time(NULL); 
  gRandom->SetSeed(seconds);
  GlobalSeed=seconds;


  SetConfigPathAndFileName(aCP,aCFN); 
  SetIsOutputfile(0);
  SetfAction(action);
  std::cout<<"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"<<endl;
  std::cout<<"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"<<endl;
  std::cout<<"++                                                           ++"<<endl;
  std::cout<<"++                                                           ++"<<endl;
  std::cout<<"++                   WELCOME to DIGMAPS                      ++"<<endl;
  std::cout<<"++                                                           ++"<<endl;
  std::cout<<"++                                                           ++"<<endl;
  std::cout<<"++         Version: 1.01    Date: March 29th 2011            ++"<<endl;
  std::cout<<"++         Author: Auguste Besson abesson@in2p3.fr           ++"<<endl;
  std::cout<<"++               (WITHOUT OUTPUT FILE)                       ++"<<endl;
  std::cout<<"++                                                           ++"<<endl;
  std::cout<<"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"<<endl;
  std::cout<<"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"<<endl;
  fDIGPlaneArray=0;
  fDIGADCArray=0;
  fDIGBeamArray=0;
  fDIGTransportArray=0;
  ffile=0;
  ftree=0;
  fDIGInitialize=0;
  fdigbeam=0;
  fdigplane=0;
  fdigadc=0;


  Run();
  timer1.Stop();

  cout<<" REAL TIME = "<<timer1.RealTime()<<" ; CPU TIME = "<<timer1.CpuTime()<<endl;
}
//______________________________________________________________________________
//  
DIGMAPS::~DIGMAPS() { // 
  // virtual destructor
  //
}
//______________________________________________________________________________
//  
void  DIGMAPS::Run() 
{ 

  //--------read configuration
  fDIGInitialize   = new DIGInitialize("read","test",fConfigPath,fConfigFileName,fAction);
  //print output in file:
  std::streambuf* OldBuf=0;  
  std::cout<<"config file = "<<GetConfigPathAndFileName()<<endl;
  if(GetIsOutputfile()==1){
    std::cout<<"output file = "<<GetOutputPathAndFileName()<<endl;
    fOutputFileStream.open(fOutputPathAndFileName, ios::out);
    
    OldBuf = std::cout.rdbuf(fOutputFileStream.rdbuf());
    fDIGInitialize->PrintInfo();
  }else{
    std::cout<<"NO output file "<<endl;;
  }
  //---------------------------
 
  //--------Read action

  Char_t *myDoit =0;  //= (fDIGInitialize->GetActionPar()).Doit;
  Char_t *myModel=0; // = (fDIGInitialize->GetActionPar()).Model;
  myDoit = strdup((fDIGInitialize->GetActionPar()).Doit);
  myModel  = strdup((fDIGInitialize->GetActionPar()).Model);

  DIGAction *aDIGAction =0;
  aDIGAction = new DIGAction(myDoit,myModel);
  SetAction(aDIGAction);

  std::cout<<" DIGMAPS:Run:  Action ="<<myDoit<<" ; Model = "<<myModel<<endl;
 
  Int_t myAction = 0;
  Char_t action[200] = "foresee";
  // strlen(action);
  if(!std::strncmp( action, myDoit,strlen(action))  ){
    cout<<" WE CAN DO THAT !"<<endl;
    myAction=1;
  }
  Char_t action2[200] = "plot";
  if(!std::strncmp( action2, myDoit,strlen(action2))  ){
    cout<<" WE CAN PLOT THAT !"<<endl;
    myAction=2;
  }

  //---compute number of Beams to create
  Int_t TotalNumberOfBeams = 0;
  TotalNumberOfBeams  = (fDIGInitialize->GetBeamPar().NAngles);
  std::cout<<" DIGMAPS:Run TotalNumberOfBeams = "<<TotalNumberOfBeams<<endl;
  //---------------------------

  //---compute number of planes to create.
  Int_t TotalNumberOfPlanes = 0;
  TotalNumberOfPlanes = (fDIGInitialize->GetPlanePar().NGeom)
    * (fDIGInitialize->GetPlanePar().NTemperature);
  std::cout<<" DIGMAPS:Run TotalNumberOfPlanes = "<<TotalNumberOfPlanes<<endl;
  //---------------------------

  //---compute number of ADCs to create
  Int_t TotalNumberOfADCs = 0;
  TotalNumberOfADCs  = (fDIGInitialize->GetPlanePar().NADC);

  std::cout<<" DIGMAPS:Run TotalNumberOfADCs = "<<TotalNumberOfADCs<<endl;
  //---------------------------
 //---compute number of transport model to create
  Int_t TotalNumberOfTransports = 0;
  TotalNumberOfTransports  = (fDIGInitialize->GetPlanePar().NTransport);

  std::cout<<" DIGMAPS:Run TotalNumberOfTransports = "<<TotalNumberOfTransports<<endl;
 



  //-------create all Beams
  fBeamN = TotalNumberOfBeams;
  fDIGBeamArray  = new TObjArray(fBeamN);
  DIGBeam *aDIGBeam=0;              // a pointer to an ADC
  //---------------------------
  
  //-------create all planes
  fPlanesN = TotalNumberOfPlanes;
  fDIGPlaneArray  = new TObjArray(fPlanesN);
  DIGPlane *aDIGPlane=0;              // a pointer to a plane
  //---------------------------

  //-------create all ADCs
  fADCN = TotalNumberOfADCs;
  fDIGADCArray  = new TObjArray(fADCN);
  DIGADC *aDIGADC=0;              // a pointer to an ADC
  //---------------------------


  //-------create all ADCs
  fTransportN = TotalNumberOfTransports;
  fDIGTransportArray = new TObjArray(fTransportN);
  DIGTransport *aDIGTransport=0;              // a pointer to a transport model
  //---------------------------

  //----loop on all beams
  for (Int_t ibeam = 0; ibeam < (fDIGInitialize->GetBeamPar().NAngles) ; ibeam++){
    aDIGBeam = new  DIGBeam(fDIGInitialize->GetBeamPar().RunNumber,
			    fDIGInitialize->GetBeamPar().NumberOfEvents,			    
			    fDIGInitialize->GetBeamPar().ParticleDensity,
			    fDIGInitialize->GetBeamPar().ThetaIncidentDeg[ibeam],
			    fDIGInitialize->GetBeamPar().PhiIncidentDeg[ibeam],
			    fDIGInitialize->GetBeamPar().BeamOption);
    fDIGBeamArray->Add(aDIGBeam);
  }
  //---------------------------

  //----loop on all beams
  /*
    for (Int_t ibeam = 0; ibeam < TotalNumberOfBeams ; ibeam++){
    ((DIGBeam*)fDIGBeamArray->At(ibeam))->PrintInfo();
    GetBeam(ibeam)->PrintInfo();
    }
  */
  //----loop on all ADCs
  for (Int_t iADC = 0; iADC < (fDIGInitialize->GetPlanePar().NADC) ; iADC++){
    // std::cout<<" "<<iADC<<" "<<(fDIGInitialize->GetPlanePar().NADC)<<endl;
    //read ADC parameters
    aDIGADC = new DIGADC();
    aDIGADC->SetNbits(fDIGInitialize->GetADCPar(iADC).Nbits);
    //std::cout<<"N bits "<<fDIGInitialize->GetADCPar(iADC).Nbits<<" "<<aDIGADC->GetNbits()<<endl;
    aDIGADC->SetNThresholds(fDIGInitialize->GetADCPar(iADC).NThresholds);
    //std::cout<<"NThresholds "<<fDIGInitialize->GetADCPar(iADC).NThresholds<<" "<<aDIGADC->GetNThresholds()<<endl;
    aDIGADC->SetADC_linear(fDIGInitialize->GetADCPar(iADC).ADC_linear);
    //std::cout<<"ADC_linear "<<fDIGInitialize->GetADCPar(iADC).ADC_linear<<" "<<aDIGADC->GetADC_linear()<<endl;
    aDIGADC->SetLSB(fDIGInitialize->GetADCPar(iADC).LSB);
    //std::cout<<"LSB "<<fDIGInitialize->GetADCPar(iADC).LSB<<" "<<aDIGADC->GetLSB() <<endl;
    aDIGADC->SetElectron_Conversion(fDIGInitialize->GetADCPar(iADC).Electron_Conversion);
    //std::cout<<"electron_Conversion "<<fDIGInitialize->GetADCPar(iADC).Electron_Conversion<<" "<<aDIGADC->GetElectron_Conversion() <<endl;
    //for (Int_t i = 0; i <aDIGADC->GetNThresholds()  ; i++){
    //  std::cout<<"tADC_thresholds n"<<i<<" ="<<fDIGInitialize->GetADCPar(iADC).ADC_thresholds[i]<<endl;
    //}
    aDIGADC->SetADC_thresholds( (fDIGInitialize->GetADCPar(iADC).ADC_thresholds),fDIGInitialize->GetADCPar(iADC).NThresholds);
    //std::cout<<"tADC_thresholds " <<endl;
    // aDIGADC->PrintInfo();
    fDIGADCArray->Add(aDIGADC);
  }
   
  //  std::cout<<"2nd loop on ADCs"<<endl;
  /*
    for (Int_t iADC = 0; iADC < (fDIGInitialize->GetPlanePar().NADC) ; iADC++){
    ((DIGADC*)fDIGADCArray->At(iADC))->PrintInfo();
    }
  */
  //---------------------------
 //----loop on all transport models
  for (Int_t itrans = 0; itrans < (fDIGInitialize->GetPlanePar().NTransport) ; itrans++){    

    aDIGTransport = new DIGTransport();
    aDIGTransport->SetChargeModel(fDIGInitialize->GetTransportPar(itrans).ChargeModel );
    aDIGTransport->SetLorentz2DModel_Cp0(fDIGInitialize->GetTransportPar(itrans).Lorentz2DModel_Cp0);
    aDIGTransport->SetLorentz2DModel_Cp1(fDIGInitialize->GetTransportPar(itrans).Lorentz2DModel_Cp1);
    aDIGTransport->SetRangeLimit_InPitchUnit(fDIGInitialize->GetTransportPar(itrans).RangeLimit_InPitchUnit);
    aDIGTransport->SetGauss2DModel_sigma1_Cp0(fDIGInitialize->GetTransportPar(itrans).Gauss2DModel_sigma1_Cp0);
    aDIGTransport->SetGauss2DModel_sigma1_Cp1(fDIGInitialize->GetTransportPar(itrans).Gauss2DModel_sigma1_Cp1);
    aDIGTransport->SetGauss2DModel_sigma2_Cp0(fDIGInitialize->GetTransportPar(itrans).Gauss2DModel_sigma2_Cp0);
    aDIGTransport->SetGauss2DModel_sigma2_Cp1(fDIGInitialize->GetTransportPar(itrans).Gauss2DModel_sigma2_Cp1);
    aDIGTransport->SetGauss2DModel_weight(fDIGInitialize->GetTransportPar(itrans).Gauss2DModel_weight);
    aDIGTransport->SetLorGaussModel_Norm1_Cp0(fDIGInitialize->GetTransportPar(itrans).LorGaussModel_Norm1_Cp0);
    aDIGTransport->SetLorGaussModel_Norm1_Cp1(fDIGInitialize->GetTransportPar(itrans).LorGaussModel_Norm1_Cp1);
    aDIGTransport->SetLorGaussModel_Norm1_Cp2(fDIGInitialize->GetTransportPar(itrans).LorGaussModel_Norm1_Cp2);
    aDIGTransport->SetLorGaussModel_sigma_Cp0(fDIGInitialize->GetTransportPar(itrans).LorGaussModel_sigma_Cp0);
    aDIGTransport->SetLorGaussModel_sigma_Cp1(fDIGInitialize->GetTransportPar(itrans).LorGaussModel_sigma_Cp1);
    aDIGTransport->SetLorGaussModel_C_Cp0(fDIGInitialize->GetTransportPar(itrans).LorGaussModel_C_Cp0);
    aDIGTransport->SetLorGaussModel_C_Cp1(fDIGInitialize->GetTransportPar(itrans).LorGaussModel_C_Cp1);
    aDIGTransport->SetLorGaussModel_Norm_Cp0(fDIGInitialize->GetTransportPar(itrans).LorGaussModel_Norm_Cp0);
    aDIGTransport->SetLorGaussModel_Norm_Cp1(fDIGInitialize->GetTransportPar(itrans).LorGaussModel_Norm_Cp1);

    fDIGTransportArray->Add(aDIGTransport);
  }

  for (Int_t igeom = 0; igeom < (fDIGInitialize->GetPlanePar().NGeom) ; igeom++){    
    for (Int_t itemp = 0; itemp < (fDIGInitialize->GetPlanePar().NTemperature) ; itemp++){
      aDIGPlane  = new DIGPlane();
      aDIGPlane->SetPitch((fDIGInitialize->GetPlanePar().PitchX[igeom]),(fDIGInitialize->GetPlanePar().PitchY[igeom]));
      aDIGPlane->SetNpixels((fDIGInitialize->GetPlanePar().NPixelsX),(fDIGInitialize->GetPlanePar().NPixelsY));
      Float_t tempDimensionX = (fDIGInitialize->GetPlanePar().NPixelsX)*(fDIGInitialize->GetPlanePar().PitchX[igeom]);
      Float_t tempDimensionY = (fDIGInitialize->GetPlanePar().NPixelsY)*(fDIGInitialize->GetPlanePar().PitchY[igeom]);
      Float_t tempDimensionZ = (fDIGInitialize->GetPlanePar().EpitaxialThickness[igeom]);
      aDIGPlane->SetDimensions(tempDimensionX,tempDimensionY,tempDimensionZ);
      aDIGPlane->SetNoiseElectrons((fDIGInitialize->GetPlanePar().NoiseElectrons[igeom]));
      aDIGPlane->SetTemperature((fDIGInitialize->GetPlanePar().Temperature[itemp]));
      aDIGPlane->SetIonizationEnergy((fDIGInitialize->GetPlanePar().IonizationEnergy));
      aDIGPlane->SetSegmentSize((fDIGInitialize->GetPlanePar().SegmentSize));
      aDIGPlane->SetMaximumSegmentSize((fDIGInitialize->GetPlanePar().MaximumSegmentSize));
      aDIGPlane->SetMaximumChargePerSegment((fDIGInitialize->GetPlanePar().MaximumChargePerSegment));
      aDIGPlane->SetDiffusionMaximumRange((fDIGInitialize->GetPlanePar().DiffusionMaximumRangeInX),
					  (fDIGInitialize->GetPlanePar().DiffusionMaximumRangeInY));
      aDIGPlane->SetReflexionCoefficient((fDIGInitialize->GetPlanePar().ReflexionCoefficient));
      aDIGPlane->SetBasicModel_SigmaTenMicrons((fDIGInitialize->GetPlanePar().BasicModel_SigmaTenMicrons));

      fDIGPlaneArray->Add(aDIGPlane);
    }
  }

  
  //------------compute total number of configurations
  Int_t mynumberofconfigurations = TotalNumberOfBeams* TotalNumberOfPlanes *TotalNumberOfADCs*TotalNumberOfTransports;
  SetNumberOfConfigurations(mynumberofconfigurations);


  //---------------------------
  if(myAction==1) {
    //---------------------------
    

    //----------create tree:
    //----------create tree with all classes.
    //TFile myfile("tree.root","RECREATE");
    //TTree mytree("mytree","DIGMAPS tree");
   
    ffile = new TFile("tree.root","RECREATE");
    ftree = new TTree("mytree","DIGMAPS tree");

    fdigbeam = new DIGBeam();
    ftree->Branch("beam_branch","DIGBeam",&fdigbeam,32000,1);

    fdigplane = new DIGPlane();
    ftree->Branch("plane_branch","DIGPlane",&fdigplane,32000,1);

    fdigadc = new DIGADC();
    ftree->Branch("adc_branch","DIGADC",&fdigadc,32000,1);
  
    fdigtransport = new DIGTransport();
    ftree->Branch("transport_branch","DIGTransport",&fdigtransport,32000,1);

    fdigevent = new DIGEvent();
    ftree->Branch("event_branch","DIGEvent",&fdigevent,32000,99);
    //---------------------------
    Int_t iconfigcounter =0;
    //-------------------------------------------------------------------------------------
    //--------------Loop on all configurations.
    //-------------------------------------------------------------------------------------
    for (Int_t ibeam = 0; ibeam < TotalNumberOfBeams ; ibeam++){    
      for (Int_t iplane = 0; iplane < TotalNumberOfPlanes ; iplane++){    
	for (Int_t iadc = 0; iadc < TotalNumberOfADCs ; iadc++){    
	  for (Int_t itransport = 0; itransport < TotalNumberOfTransports ; itransport++){    
	  std::cout<<"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"<<endl;
	  std::cout<<"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"<<endl;
	  std::cout<<"                                                               "<<endl;
	  std::cout<<"        Configuration number " <<iconfigcounter+1 <<" / "<< mynumberofconfigurations<<endl;
	  std::cout<<"         ibeam "<<ibeam <<endl;
	  std::cout<<"         iplane "<<iplane <<endl;
	  std::cout<<"         iadc "<<iadc <<endl;
	  std::cout<<"         itransport "<< itransport<<endl;
	  std::cout<<"                                                               "<<endl;
	  std::cout<<"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"<<endl;
	  std::cout<<"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"<<endl;
	  RunConfiguration(iconfigcounter,ibeam,iplane,iadc,itransport);
	  iconfigcounter++;
	  }
	}
      }
    }
    ffile->Write();
    delete fdigevent;
    delete fdigbeam;
    delete fdigplane;
    delete fdigtransport;
    delete fdigadc;
    //-------------------------------------------------------------------------------------
  }// end Action ==1

  if(myAction==2){
    cout<<"Time to read the tree ! "<<endl;
    ActionPlot();
  }

 
  PrintConfigurations();

  std::cout.rdbuf(OldBuf);
  fOutputFileStream.close();

  PrintConfigurations();


  cout<<" ... END"<<endl;

  /*  time_t seconds;
      seconds = time(NULL);
      cout<<"TIME "<< seconds<<endl;
  */
}
//______________________________________________________________________________
//  
void  DIGMAPS::ActionPlot()
{


  //-------------------------------------------
  //---------Declare histograms
  //-------------------------------------------

  DIGHistograms::BookHistograms(GetNumberOfConfigurations());


  //-------------------------------------------
  //---------Open tree
  //-------------------------------------------
  
  cout<<"Time to read the tree ! "<<endl;
  ffile = new TFile("tree.root","READ");
  //   ftree = new TTree("mytree","DIGMAPS tree");
  ftree=(TTree*) ffile->Get("mytree");

  DIGBeam *mydigBeam = new DIGBeam();
  TBranch *branchdigBeam = ftree->GetBranch("beam_branch");
  branchdigBeam->SetAddress(&mydigBeam);

  DIGPlane *mydigPlane = new DIGPlane();
  TBranch *branchdigPlane= ftree->GetBranch("plane_branch");
  branchdigPlane->SetAddress(&mydigPlane);

  DIGADC *mydigADC = new DIGADC();
  TBranch *branchdigADC= ftree->GetBranch("adc_branch");
  branchdigADC->SetAddress(&mydigADC);

  DIGTransport *mydigTransport = new DIGTransport();
  TBranch *branchdigTransport= ftree->GetBranch("transport_branch");
  branchdigTransport->SetAddress(&mydigTransport);


    
  DIGEvent *mydigEvent = new DIGEvent();
  TBranch *branchdigEvent= ftree->GetBranch("event_branch");
  branchdigEvent->SetAddress(&mydigEvent);
    
  Int_t NEVENT = (Int_t) ftree->GetEntries() ;

  Int_t MinEvent = 0;
  Int_t MaxEvent = NEVENT;


  
  Int_t Current_configuration = 0;
  // Int_t Former_configuration =0;
  // **********************************************************************************
  // ********* MAIN LOOP ***************
  // **********************************************************************************
  for ( Int_t ievt=MinEvent ; ievt<=MaxEvent ; ievt++ ) {
    ftree->GetEvent(ievt);
    cout<<"+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Event ievt "<<ievt<<endl;
    //cout<<" DIGBEAM  TEST:: GetThetaIncidentDeg "<<mydigBeam->GetThetaIncidentDeg()<<endl;
    //cout<<" DIGPLANE TEST:: GetPitchX "<<mydigPlane->GetPitchX() <<endl;
    //cout<<" DIGADC   TEST:: GetNbits() "<<mydigADC->GetNbits() <<endl;

    //-------------------------------------------
    //---------get the configuration
    //-------------------------------------------
    
    Current_configuration = mydigEvent->GetConfigurationNumber();
 

    //-------------------------------------------
    //---------Get transport model and plot it
    //-------------------------------------------

    //mydigTransport->GetChargeModel()

    // if model == 1 then store tels parametres.

    // create a function with such parametersxs  
    // On a deja: Double_t DIGMAPS::Lorentz2D(Double_t *x, Double_t *par){
    // copier la 2xgaus2d et la lor+gauss

    // en fait il faudrait stocker une funtion plutot qu'un histo.

    // creer des histo 2d charge vs distance.

    //loop sur tous les clusters, acces a tous les pixels du cluster, acces a leur charge digitise et leur position, 
    //acces a la position de la trace, calcul de la distance
    //remplissage de l'histo 2d.

    //-------------------------------------------
    //---------loop on ADC thresholds
    //-------------------------------------------
    for ( Int_t i=0 ; i<mydigADC->GetNThresholds() ; i++ ) {
      //      cout<<"threshold "<<i<<" "<<mydigADC->GetADC_thresholds()[i]<<endl;
    }    
    //-------------------------------------------
    //---------Print info
    //-------------------------------------------
    //mydigEvent->PrintInfo();


    //-------------------------------------------
    //----------get particles of the event
    //-------------------------------------------
    TClonesArray       *myDIGParticleArray = mydigEvent->GetParticle();
    DIGParticle* TheParticle =0;
    Int_t NbOfParticles = myDIGParticleArray->GetLast()+1   ;
    Int_t j=0;
    vector< Bool_t > ClusterAssociated;
    ClusterAssociated.resize(mydigEvent->GetNClusters());
    for (Int_t i = 0; i < mydigEvent->GetNClusters() ; i++){
      ClusterAssociated[i]=false;
    }


    while(j<NbOfParticles) {
      TheParticle=(DIGParticle*) myDIGParticleArray->At(j) ;
      //TheParticle->PrintInfo();


      ((TH1F*) Ar_h1_Particle_TotalAnalogCharge->At(Current_configuration))->Fill( TheParticle->GetTotalAnalogCharge() );
      ((TH1F*) Ar_h1_Particle_TotalDigitalCharge->At(Current_configuration))->Fill( TheParticle->GetTotalDigitalCharge() );
      ((TH1F*) Ar_h1_Particle_Energy_deposited->At(Current_configuration))->Fill( TheParticle->GetEnergy_deposited() );

      
      ((TH2F*) Ar_h2_Particle_EnergyDeposited_vs_TotalAnalogCharge->At(Current_configuration))
	->Fill(TheParticle->GetTotalAnalogCharge(),TheParticle->GetEnergy_deposited());    
      ((TH2F*) Ar_h2_Particle_TotalDigitalCharge_vs_TotalAnalogCharge->At(Current_configuration))
      	->Fill(TheParticle->GetTotalAnalogCharge(),TheParticle->GetTotalDigitalCharge());
  

      //--------------loop on clusters and associate each particle to one cluster
      TClonesArray       *myDIGClusterArray = mydigEvent->GetCluster();
      DIGCluster* TheCluster =0;
      Int_t NbOfCluster = myDIGClusterArray->GetLast()+1   ;
      Int_t k=0;
      
      Float_t trackHitdistance = 100000000.0;
      Int_t theclusterNumber = 0;
      Double_t ClusterCoGX = 0.0;
      Double_t ClusterCoGY = 0.0;
      Double_t theClusterCoGX = 0.0;
      Double_t theClusterCoGY = 0.0;
      Float_t TrackX = (TheParticle->GetEntryX() + TheParticle->GetExitX())/2.0;
      Float_t TrackY = (TheParticle->GetEntryY() + TheParticle->GetExitY())/2.0;
      
      while(k<NbOfCluster) {
	TheCluster=(DIGCluster*) myDIGClusterArray->At(k) ;
	ClusterCoGX = TheCluster->GetXposition_CoG();
	ClusterCoGY = TheCluster->GetYposition_CoG();
	Double_t currentdist = TMath::Sqrt((TrackX-ClusterCoGX)*(TrackX-ClusterCoGX) + (TrackY-ClusterCoGY)*(TrackY-ClusterCoGY));
	if((currentdist<trackHitdistance)&&(ClusterAssociated[k]==false)){
	  theclusterNumber = k;
	  trackHitdistance = currentdist;
	  theClusterCoGX = ClusterCoGX;
	  theClusterCoGY = ClusterCoGY;
	}	
	k++;
      }
      
      //--------------end loop on clusters
      Float_t distancemax = 5.0*TMath::Sqrt(mydigPlane->GetPitchX()*mydigPlane->GetPitchX()+mydigPlane->GetPitchY()*mydigPlane->GetPitchY());
      if(trackHitdistance < distancemax ){
	ClusterAssociated[theclusterNumber]=true;
      }
      
      ((TH1F*) Ar_h1_Resolution_ResidualX_CoG_true->At(Current_configuration))->Fill(TrackX - theClusterCoGX);
      ((TH1F*) Ar_h1_Resolution_ResidualY_CoG_true->At(Current_configuration))->Fill(TrackY - theClusterCoGY);
      ((TH1F*) Ar_h1_Resolution_Residualdist_CoG_true->At(Current_configuration))->Fill(trackHitdistance);
      ((TH2F*) Ar_h2_Resolution_TruePosition->At(Current_configuration))->Fill(TrackX,TrackY);
      ((TH2F*) Ar_h2_Resolution_TruePosition_modulo->At(Current_configuration))
	->Fill(TrackX-int(TrackX)+int(TrackX)%(int(mydigPlane->GetPitchX())) ,TrackY-int(TrackY)+int(TrackY)%(int(mydigPlane->GetPitchY()))   );
      ((TH2F*) Ar_h2_Resolution_CoG->At(Current_configuration))->Fill(ClusterCoGX,ClusterCoGY);
      ((TH2F*) Ar_h2_Resolution_CoG_modulo->At(Current_configuration))
	->Fill(ClusterCoGX-int(ClusterCoGX)+int(ClusterCoGX)%(int(mydigPlane->GetPitchX())),ClusterCoGY-int(ClusterCoGY)+int(ClusterCoGY)%(int(mydigPlane->GetPitchY())));
      
      

      j++;
    } //----end loop on particles
    if(mydigEvent->GetNParticles() !=myDIGParticleArray->GetLast()+1){
      cout<< "DIGEVENT TEST:: WARNING PROBLEM IN PARTICLE RECORDING"<<endl;
      cout<<mydigEvent->GetNParticles()<<" != "<<myDIGParticleArray->GetLast()+1<<endl;
    }else{
      //cout<<mydigEvent->GetNParticles()<<" === "<<myDIGParticleArray->GetLast()+1<<endl;
    }

    //-------------------------------------------
    //----------get clusters of the event
    //-------------------------------------------
    TClonesArray       *myDIGClusterArray = mydigEvent->GetCluster();
    DIGCluster* TheCluster =0;
    Int_t NbOfCluster = myDIGClusterArray->GetLast()+1   ;
    Int_t k=0;

    if(mydigEvent->GetNClusters() !=myDIGClusterArray->GetLast()+1){
      cout<< "DIGEVENT TEST:: WARNING PROBLEM IN CLUSTERS RECORDING"<<endl;
      cout<<mydigEvent->GetNClusters()<<" != "<<myDIGClusterArray->GetLast()+1<<endl;
    }else{
      //cout<<mydigEvent->GetNClusters()<<" === "<<myDIGClusterArray->GetLast()+1<<endl;
    }

    while(k<NbOfCluster) {
      TheCluster=(DIGCluster*) myDIGClusterArray->At(k) ;
      TheCluster->PrintInfo();
      
      ((TH1F*) Ar_h1_multiplicity_with_threshold_01->At(Current_configuration))->Fill(TheCluster->GetMultiplicity(1));
      ((TH1F*) Ar_h1_multiplicity_with_threshold_02->At(Current_configuration))->Fill(TheCluster->GetMultiplicity(2));
      ((TH1F*) Ar_h1_multiplicity_with_threshold_03->At(Current_configuration))->Fill(TheCluster->GetMultiplicity(3));
      ((TH1F*) Ar_h1_multiplicity_with_threshold_04->At(Current_configuration))->Fill(TheCluster->GetMultiplicity(4));
      ((TH1F*) Ar_h1_multiplicity_with_threshold_05->At(Current_configuration))->Fill(TheCluster->GetMultiplicity(5));
      ((TH1F*) Ar_h1_multiplicity_with_threshold_06->At(Current_configuration))->Fill(TheCluster->GetMultiplicity(6));
      ((TH1F*) Ar_h1_multiplicity_with_threshold_07->At(Current_configuration))->Fill(TheCluster->GetMultiplicity(7));
      ((TH1F*) Ar_h1_multiplicity_with_threshold_08->At(Current_configuration))->Fill(TheCluster->GetMultiplicity(8));
      ((TH1F*) Ar_h1_multiplicity_with_threshold_09->At(Current_configuration))->Fill(TheCluster->GetMultiplicity(9));
      ((TH1F*) Ar_h1_multiplicity_with_threshold_10->At(Current_configuration))->Fill(TheCluster->GetMultiplicity(10));
 
      ((TH1F*) Ar_h1_Cluster_SeedDigitalCharge->At(Current_configuration))->Fill(float(TheCluster->GetDigitalCharge()[TheCluster->GetSeedPixelIndex()]) );
      ((TH1F*) Ar_h1_Cluster_TotalDigitalCharge->At(Current_configuration))->Fill(  TheCluster->GetTotalCharge() );
      ((TH1F*) Ar_h1_Cluster_9x9DigitalCharge->At(Current_configuration))
	->Fill( TheCluster->GetDigitalCharge()[TheCluster->GetSeedPixelIndex()]+  TheCluster->Get1stCrownCharge(mydigPlane) );
      ((TH1F*) Ar_h1_Cluster_1stCrownDigitalCharge->At(Current_configuration))->Fill(TheCluster->Get1stCrownCharge(mydigPlane));
      ((TH1F*) Ar_h1_Cluster_2ndCrownDigitalCharge->At(Current_configuration))->Fill(TheCluster->Get2ndCrownCharge(mydigPlane));
      ((TH1F*) Ar_h1_Cluster_4NeighboursDigitalCharge->At(Current_configuration))->Fill(TheCluster->Get4NeigboursCharge(mydigPlane));



      ((TH1F*)  Ar_h1_test->At(Current_configuration))
	->Fill( (TheCluster->Get1stCrownCharge(mydigPlane) +TheCluster->Get2ndCrownCharge(mydigPlane)
		 +TheCluster->GetDigitalCharge()[TheCluster->GetSeedPixelIndex()]));


      if( TheCluster->GetTotalCharge()!=0){
	((TH1F*) Ar_h1_Cluster_SeedOverTotalDigitalCharge->At(Current_configuration))
	  ->Fill(TheCluster->GetDigitalCharge()[TheCluster->GetSeedPixelIndex()] / float(TheCluster->GetTotalCharge()) );
	((TH1F*) Ar_h1_Cluster_1stCrownOverTotalDigitalCharge->At(Current_configuration))
	  ->Fill(TheCluster->Get1stCrownCharge(mydigPlane)/ float(TheCluster->GetTotalCharge()) );
	((TH1F*) Ar_h1_Cluster_2ndCrownOverTotalDigitalCharge->At(Current_configuration))
	  ->Fill(TheCluster->Get2ndCrownCharge(mydigPlane)/ float(TheCluster->GetTotalCharge()) );
	((TH1F*) Ar_h1_Cluster_4NeighboursOverTotalDigitalCharge->At(Current_configuration))
	  ->Fill(TheCluster->Get4NeigboursCharge(mydigPlane)/ float(TheCluster->GetTotalCharge()) );
      }

      k++;
    }

    //-------------------------------------------
    //---------Get read out map of the event
    //-------------------------------------------

    DIGReadoutmap *myDIGReadoutmap = mydigEvent->GetReadoutmap();
    //myDIGReadoutmap->PrintInfo();
    Int_t Nx = mydigPlane->GetNpixelsX();
    Int_t Ny = mydigPlane->GetNpixelsY();
    myDIGReadoutmap->PrintOuput(Nx,Ny);

  }
  // **********************************************************************************
  // ********* END OF MAIN LOOP ***************
  // **********************************************************************************


  

}
//______________________________________________________________________________
//  
void  DIGMAPS::PlotAConfiguration(Int_t confignumber, Bool_t newcanvas)
{
  Int_t ColorChosen =1;

  if(newcanvas==1){
    MainCanvas1 = new TCanvas("MainCanvas1","MainCanvas1",450,10,1000,950);
    MainCanvas1->Divide(3,4);
    MainCanvas1->Update();
    MainCanvas2 = new TCanvas("MainCanvas2","MainCanvas2",550,10,1000,950);
    MainCanvas2->Divide(2,4);
    MainCanvas2->Update();
    MainCanvas3 = new TCanvas("MainCanvas3","MainCanvas3",650,10,1000,950);
    MainCanvas3->Divide(2,4);
    MainCanvas3->Update();
    MainCanvas4 = new TCanvas("MainCanvas4","MainCanvas4",750,10,1000,950);
    MainCanvas4->Divide(2,4);
    MainCanvas4->Update();


  }else{
    ColorChosen++;
    ColorChosen++;
  }

  Float_t integ ;
  //------------MainCanvas1
  MainCanvas1->cd(1);
  integ =((TH1F*)Ar_h1_multiplicity_with_threshold_01->At(confignumber))->Integral();
  if(integ!=0.0){((TH1F*)Ar_h1_multiplicity_with_threshold_01->At(confignumber))->Scale(1/integ);}
  ((TH1F*)(Ar_h1_multiplicity_with_threshold_01->At(confignumber)))->SetAxisRange(0,0.3,"Y"); 
  ((TH1F*)(Ar_h1_multiplicity_with_threshold_01->At(confignumber)))->SetLineColor(ColorChosen);
  if(newcanvas==1){
    (Ar_h1_multiplicity_with_threshold_01->At(confignumber))->Draw();
  }else{
    (Ar_h1_multiplicity_with_threshold_01->At(confignumber))->Draw("same");
  }
  MainCanvas1->cd(2);
  integ =((TH1F*)Ar_h1_multiplicity_with_threshold_02->At(confignumber))->Integral();
  if(integ!=0.0){((TH1F*)Ar_h1_multiplicity_with_threshold_02->At(confignumber))->Scale(1/integ);}
  ((TH1F*)(Ar_h1_multiplicity_with_threshold_02->At(confignumber)))->SetAxisRange(0,0.3,"Y"); 
  ((TH1F*)(Ar_h1_multiplicity_with_threshold_02->At(confignumber)))->SetLineColor(ColorChosen);
  if(newcanvas==1){
    (Ar_h1_multiplicity_with_threshold_02->At(confignumber))->Draw();
  }else{
    (Ar_h1_multiplicity_with_threshold_02->At(confignumber))->Draw("same");
  }
  MainCanvas1->cd(3);
  integ =((TH1F*)Ar_h1_multiplicity_with_threshold_03->At(confignumber))->Integral();
  if(integ!=0.0){((TH1F*)Ar_h1_multiplicity_with_threshold_03->At(confignumber))->Scale(1/integ);}
  ((TH1F*)(Ar_h1_multiplicity_with_threshold_03->At(confignumber)))->SetAxisRange(0,0.3,"Y"); 
  ((TH1F*)(Ar_h1_multiplicity_with_threshold_03->At(confignumber)))->SetLineColor(ColorChosen);
  if(newcanvas==1){
    (Ar_h1_multiplicity_with_threshold_03->At(confignumber))->Draw();
  }else{
    (Ar_h1_multiplicity_with_threshold_03->At(confignumber))->Draw("same");
  }
  MainCanvas1->cd(4);
  integ =((TH1F*)Ar_h1_multiplicity_with_threshold_04->At(confignumber))->Integral();
  if(integ!=0.0){((TH1F*)Ar_h1_multiplicity_with_threshold_04->At(confignumber))->Scale(1/integ);}
  ((TH1F*)(Ar_h1_multiplicity_with_threshold_04->At(confignumber)))->SetAxisRange(0,0.3,"Y"); 
  ((TH1F*)(Ar_h1_multiplicity_with_threshold_04->At(confignumber)))->SetLineColor(ColorChosen);
  if(newcanvas==1){
    (Ar_h1_multiplicity_with_threshold_04->At(confignumber))->Draw();
  }else{
    (Ar_h1_multiplicity_with_threshold_04->At(confignumber))->Draw("same");
  }
  MainCanvas1->cd(5);
  integ =((TH1F*)Ar_h1_multiplicity_with_threshold_05->At(confignumber))->Integral();
  if(integ!=0.0){((TH1F*)Ar_h1_multiplicity_with_threshold_05->At(confignumber))->Scale(1/integ);}
  ((TH1F*)(Ar_h1_multiplicity_with_threshold_05->At(confignumber)))->SetAxisRange(0,0.3,"Y");
  ((TH1F*)(Ar_h1_multiplicity_with_threshold_05->At(confignumber)))->SetLineColor(ColorChosen);
  if(newcanvas==1){
    (Ar_h1_multiplicity_with_threshold_05->At(confignumber))->Draw();
  }else{
    (Ar_h1_multiplicity_with_threshold_05->At(confignumber))->Draw("same");
  }
  MainCanvas1->cd(6);
  integ =((TH1F*)Ar_h1_multiplicity_with_threshold_06->At(confignumber))->Integral();
  if(integ!=0.0){((TH1F*)Ar_h1_multiplicity_with_threshold_06->At(confignumber))->Scale(1/integ);}
  ((TH1F*)(Ar_h1_multiplicity_with_threshold_06->At(confignumber)))->SetAxisRange(0,0.3,"Y"); 
  ((TH1F*)(Ar_h1_multiplicity_with_threshold_06->At(confignumber)))->SetLineColor(ColorChosen);
  if(newcanvas==1){
    (Ar_h1_multiplicity_with_threshold_06->At(confignumber))->Draw();
  }else{
    (Ar_h1_multiplicity_with_threshold_06->At(confignumber))->Draw("same");
  }
  MainCanvas1->cd(7);
  integ =((TH1F*)Ar_h1_multiplicity_with_threshold_07->At(confignumber))->Integral();
  if(integ!=0.0){((TH1F*)Ar_h1_multiplicity_with_threshold_07->At(confignumber))->Scale(1/integ);}
  ((TH1F*)(Ar_h1_multiplicity_with_threshold_07->At(confignumber)))->SetAxisRange(0,0.3,"Y");
  ((TH1F*)(Ar_h1_multiplicity_with_threshold_07->At(confignumber)))->SetLineColor(ColorChosen);
  if(newcanvas==1){
    (Ar_h1_multiplicity_with_threshold_07->At(confignumber))->Draw();
  }else{
    (Ar_h1_multiplicity_with_threshold_07->At(confignumber))->Draw("same");
  }
  MainCanvas1->cd(8);
  integ =((TH1F*)Ar_h1_multiplicity_with_threshold_08->At(confignumber))->Integral();
  if(integ!=0.0){((TH1F*)Ar_h1_multiplicity_with_threshold_08->At(confignumber))->Scale(1/integ);}
  ((TH1F*)(Ar_h1_multiplicity_with_threshold_08->At(confignumber)))->SetAxisRange(0,0.3,"Y"); 
  ((TH1F*)(Ar_h1_multiplicity_with_threshold_08->At(confignumber)))->SetLineColor(ColorChosen);
  if(newcanvas==1){
    (Ar_h1_multiplicity_with_threshold_08->At(confignumber))->Draw();
  }else{
    (Ar_h1_multiplicity_with_threshold_08->At(confignumber))->Draw("same");
  }
  MainCanvas1->cd(9);
  integ =((TH1F*)Ar_h1_multiplicity_with_threshold_09->At(confignumber))->Integral();
  if(integ!=0.0){((TH1F*)Ar_h1_multiplicity_with_threshold_09->At(confignumber))->Scale(1/integ);}
  ((TH1F*)(Ar_h1_multiplicity_with_threshold_09->At(confignumber)))->SetAxisRange(0,0.3,"Y"); 
  ((TH1F*)(Ar_h1_multiplicity_with_threshold_09->At(confignumber)))->SetLineColor(ColorChosen);
  if(newcanvas==1){
    (Ar_h1_multiplicity_with_threshold_09->At(confignumber))->Draw();
  }else{
    (Ar_h1_multiplicity_with_threshold_09->At(confignumber))->Draw("same");
  }
  MainCanvas1->cd(10);
  integ =((TH1F*)Ar_h1_multiplicity_with_threshold_10->At(confignumber))->Integral();
  if(integ!=0.0){((TH1F*)Ar_h1_multiplicity_with_threshold_10->At(confignumber))->Scale(1/integ);}
  ((TH1F*)(Ar_h1_multiplicity_with_threshold_10->At(confignumber)))->SetAxisRange(0,0.3,"Y"); 
  ((TH1F*)(Ar_h1_multiplicity_with_threshold_10->At(confignumber)))->SetLineColor(ColorChosen);
  if(newcanvas==1){
    (Ar_h1_multiplicity_with_threshold_10->At(confignumber))->Draw();
  }else{
    (Ar_h1_multiplicity_with_threshold_10->At(confignumber))->Draw("same");
  }

  //------------MainCanvas2
  MainCanvas2->cd(1);
  ((TH1F*)Ar_h1_Cluster_SeedDigitalCharge->At(confignumber))->Draw("HIST");
  ((TH1F*)Ar_h1_Cluster_SeedDigitalCharge->At(confignumber))->Sumw2();
  integ = ((TH1F*)Ar_h1_Cluster_SeedDigitalCharge->At(confignumber))->Integral();
  if(integ!=0.0){((TH1F*)Ar_h1_Cluster_SeedDigitalCharge->At(confignumber))->Scale(1/integ);}
  ((TH1F*)Ar_h1_Cluster_SeedDigitalCharge->At(confignumber))->Fit("landau","","same");
 
  MainCanvas2->cd(2);
  ((TH1F*)Ar_h1_Cluster_TotalDigitalCharge->At(confignumber))->Draw("HIST");
  ((TH1F*)Ar_h1_Cluster_TotalDigitalCharge->At(confignumber))->Sumw2();
  integ = ((TH1F*)Ar_h1_Cluster_TotalDigitalCharge->At(confignumber))->Integral();
  if(integ!=0.0){((TH1F*)Ar_h1_Cluster_TotalDigitalCharge->At(confignumber))->Scale(1/integ);}
   ((TH1F*)Ar_h1_Cluster_TotalDigitalCharge->At(confignumber))->Fit("landau","","same");

  MainCanvas2->cd(3);
  ((TH1F*)Ar_h1_Particle_TotalAnalogCharge->At(confignumber))->Draw("HIST");
  ((TH1F*)Ar_h1_Particle_TotalAnalogCharge->At(confignumber))->Sumw2();
  integ = ((TH1F*)Ar_h1_Particle_TotalAnalogCharge->At(confignumber))->Integral();
  if(integ!=0.0){((TH1F*)Ar_h1_Particle_TotalAnalogCharge->At(confignumber))->Scale(1/integ);}
  ((TH1F*)Ar_h1_Particle_TotalAnalogCharge->At(confignumber))->Fit("landau","","same");

  MainCanvas2->cd(4);
  ((TH1F*)Ar_h1_Particle_TotalDigitalCharge->At(confignumber))->Draw("HIST");
  ((TH1F*)Ar_h1_Particle_TotalDigitalCharge->At(confignumber))->Sumw2();
  integ = ((TH1F*)Ar_h1_Particle_TotalDigitalCharge->At(confignumber))->Integral();
  if(integ!=0.0){((TH1F*)Ar_h1_Particle_TotalDigitalCharge->At(confignumber))->Scale(1/integ);}
  ((TH1F*)Ar_h1_Particle_TotalDigitalCharge->At(confignumber))->Fit("landau","","same");

  MainCanvas2->cd(5);
  ((TH1F*)Ar_h1_Particle_Energy_deposited->At(confignumber))->Draw("HIST");
  ((TH1F*)Ar_h1_Particle_Energy_deposited->At(confignumber))->Sumw2();
  integ = ((TH1F*)Ar_h1_Particle_Energy_deposited->At(confignumber))->Integral();
  if(integ!=0.0){((TH1F*)Ar_h1_Particle_Energy_deposited->At(confignumber))->Scale(1/integ);}
 ((TH1F*)Ar_h1_Particle_Energy_deposited->At(confignumber))->Fit("landau","","same");

  MainCanvas2->cd(6);
  ((TH2F*)Ar_h2_Particle_EnergyDeposited_vs_TotalAnalogCharge->At(confignumber))->Draw("colz");

  MainCanvas2->cd(7);    
  ((TH2F*)Ar_h2_Particle_TotalDigitalCharge_vs_TotalAnalogCharge->At(confignumber))->Draw("colz");

  //------------MainCanvas3
  MainCanvas3->cd(1);  
  ((TH1F*)(Ar_h1_Cluster_9x9DigitalCharge->At(confignumber)))->SetLineColor(ColorChosen);
  ((TH1F*)Ar_h1_Cluster_9x9DigitalCharge->At(confignumber))->Draw();
  MainCanvas3->cd(2);    
  ((TH1F*)Ar_h1_Cluster_1stCrownDigitalCharge->At(confignumber))->SetLineColor(ColorChosen);
  if(newcanvas==1){
     ((TH1F*)Ar_h1_Cluster_1stCrownDigitalCharge->At(confignumber))->Draw();
  }else{
     ((TH1F*)Ar_h1_Cluster_1stCrownDigitalCharge->At(confignumber))->Draw("same");
  }
 
  MainCanvas3->cd(3);    
  ((TH1F*)Ar_h1_Cluster_2ndCrownDigitalCharge->At(confignumber))->SetLineColor(ColorChosen);
  if(newcanvas==1){
      ((TH1F*)Ar_h1_Cluster_2ndCrownDigitalCharge->At(confignumber))->Draw();
  }else{
      ((TH1F*)Ar_h1_Cluster_2ndCrownDigitalCharge->At(confignumber))->Draw("same");
  }

  MainCanvas3->cd(4);   
  ((TH1F*)Ar_h1_Cluster_4NeighboursDigitalCharge->At(confignumber))->SetLineColor(ColorChosen);
  if(newcanvas==1){
     ((TH1F*)Ar_h1_Cluster_4NeighboursDigitalCharge->At(confignumber))->Draw();
  }else{
     ((TH1F*)Ar_h1_Cluster_4NeighboursDigitalCharge->At(confignumber))->Draw("same");
  }
 
  MainCanvas3->cd(5);  
  integ = ((TH1F*)Ar_h1_Cluster_SeedOverTotalDigitalCharge->At(confignumber))->Integral();
  if(integ!=0.0){((TH1F*)Ar_h1_Cluster_SeedOverTotalDigitalCharge->At(confignumber))->Scale(1/integ);}
  ((TH1F*)Ar_h1_Cluster_SeedOverTotalDigitalCharge->At(confignumber))->SetAxisRange(0,0.07,"Y"); 
  ((TH1F*)Ar_h1_Cluster_SeedOverTotalDigitalCharge->At(confignumber))->SetLineColor(ColorChosen);
  if(newcanvas==1){
      ((TH1F*)Ar_h1_Cluster_SeedOverTotalDigitalCharge->At(confignumber))->Draw();
  }else{
      ((TH1F*)Ar_h1_Cluster_SeedOverTotalDigitalCharge->At(confignumber))->Draw("same");
  }

  MainCanvas3->cd(6);    
  integ = ((TH1F*)Ar_h1_Cluster_1stCrownOverTotalDigitalCharge->At(confignumber))->Integral();
  if(integ!=0.0){((TH1F*)Ar_h1_Cluster_1stCrownOverTotalDigitalCharge->At(confignumber))->Scale(1/integ);}
  ((TH1F*)Ar_h1_Cluster_1stCrownOverTotalDigitalCharge->At(confignumber))->SetAxisRange(0,0.09,"Y"); 
  ((TH1F*)Ar_h1_Cluster_1stCrownOverTotalDigitalCharge->At(confignumber))->SetLineColor(ColorChosen);
  if(newcanvas==1){
     ((TH1F*)Ar_h1_Cluster_1stCrownOverTotalDigitalCharge->At(confignumber))->Draw();
  }else{
     ((TH1F*)Ar_h1_Cluster_1stCrownOverTotalDigitalCharge->At(confignumber))->Draw("same");
  }
 
  MainCanvas3->cd(7); 
  integ = ((TH1F*)Ar_h1_Cluster_2ndCrownOverTotalDigitalCharge->At(confignumber))->Integral();
  if(integ!=0.0){((TH1F*)Ar_h1_Cluster_2ndCrownOverTotalDigitalCharge->At(confignumber))->Scale(1/integ);}   
  ((TH1F*)Ar_h1_Cluster_2ndCrownOverTotalDigitalCharge->At(confignumber))->SetAxisRange(0,0.10,"Y"); 
  ((TH1F*)Ar_h1_Cluster_2ndCrownOverTotalDigitalCharge->At(confignumber))->SetLineColor(ColorChosen);
  if(newcanvas==1){
     ((TH1F*)Ar_h1_Cluster_2ndCrownOverTotalDigitalCharge->At(confignumber))->Draw();
  }else{
     ((TH1F*)Ar_h1_Cluster_2ndCrownOverTotalDigitalCharge->At(confignumber))->Draw("same");
  }
 
  MainCanvas3->cd(8);  
  integ = ((TH1F*)Ar_h1_Cluster_4NeighboursOverTotalDigitalCharge->At(confignumber))->Integral();
  if(integ!=0.0){((TH1F*)Ar_h1_Cluster_4NeighboursOverTotalDigitalCharge->At(confignumber))->Scale(1/integ);}     
  ((TH1F*)Ar_h1_Cluster_4NeighboursOverTotalDigitalCharge->At(confignumber))->SetAxisRange(0,0.12,"Y"); 
  ((TH1F*)Ar_h1_Cluster_4NeighboursOverTotalDigitalCharge->At(confignumber))->SetLineColor(ColorChosen);
  if(newcanvas==1){
    ((TH1F*)Ar_h1_Cluster_4NeighboursOverTotalDigitalCharge->At(confignumber))->Draw();
  }else{
    ((TH1F*)Ar_h1_Cluster_4NeighboursOverTotalDigitalCharge->At(confignumber))->Draw("same");
  }
  

  //------------MainCanvas4
  MainCanvas4->cd(1);    
  ((TH1F*)Ar_h1_Resolution_ResidualX_CoG_true->At(confignumber))->Draw();
  ((TH1F*)Ar_h1_Resolution_ResidualX_CoG_true->At(confignumber))->Fit("gaus","","same");
  MainCanvas4->cd(2);    
  ((TH1F*)Ar_h1_Resolution_ResidualY_CoG_true->At(confignumber))->Draw();
((TH1F*)Ar_h1_Resolution_ResidualY_CoG_true->At(confignumber))->Fit("gaus","","same");
  MainCanvas4->cd(3);    
  ((TH1F*)Ar_h1_Resolution_Residualdist_CoG_true->At(confignumber))->Draw();
  MainCanvas4->cd(4);    
  ((TH2F*)Ar_h2_Resolution_TruePosition->At(confignumber))->Draw("colz");
  AutoZoom((TH2F*)Ar_h2_Resolution_TruePosition->At(confignumber))->Draw("colz");
  MainCanvas4->cd(5);    
  ((TH2F*)Ar_h2_Resolution_TruePosition_modulo->At(confignumber))->Draw("colz");
  AutoZoom((TH2F*)Ar_h2_Resolution_TruePosition_modulo->At(confignumber))->Draw("colz");
  MainCanvas4->cd(6);    
  ((TH2F*)Ar_h2_Resolution_CoG->At(confignumber))->Draw("colz");
  AutoZoom((TH2F*)Ar_h2_Resolution_CoG->At(confignumber))->Draw("colz");
  MainCanvas4->cd(7);    
  ((TH2F*)Ar_h2_Resolution_CoG_modulo->At(confignumber))->Draw("colz");
  AutoZoom(((TH2F*)Ar_h2_Resolution_CoG_modulo->At(confignumber)))->Draw("colz");
  MainCanvas4->cd(8);    
  

  //------------
  MainCanvas1->Update();
  MainCanvas2->Update();
  MainCanvas3->Update();
  MainCanvas4->Update();

}
//______________________________________________________________________________
//  
void  DIGMAPS::PrintConfigurations()
{
  //  fNumberOfConfigurations
    Int_t    iconfigcounter = 0;
    Int_t TotalNumberOfBeams = fBeamN;
    Int_t TotalNumberOfPlanes = fPlanesN;
    Int_t TotalNumberOfADCs =fADCN;
    Int_t TotalNumberOfTransports =fTransportN;
    std::cout<<"************************************************************** "<<endl;
    std::cout<<"           List of all configurations "<<endl;
    std::cout<<"num |Thet|Phi |Pit x X y|epi |Nois|Temp|Nbits|lin|LSB  |gain   |Model|"<<endl;
    for (Int_t ibeam = 0; ibeam < TotalNumberOfBeams ; ibeam++){    
      for (Int_t iplane = 0; iplane < TotalNumberOfPlanes ; iplane++){    
	for (Int_t iadc = 0; iadc < TotalNumberOfADCs ; iadc++){    
	  for (Int_t itransport = 0; itransport < TotalNumberOfTransports ; itransport++){    

	    Char_t charac[800];
	    sprintf(charac,"%4d|%4.1f|%4.1f|%4.1fX%4.1f|%4.1f|%4.1f|%4.1f|%2d   |%d  |%5.2f|%7.2f|%d    |\n",
		    iconfigcounter,
		    GetBeam(ibeam)->GetThetaIncidentDeg(),
		    GetBeam(ibeam)->GetPhiIncidentDeg(),
		    GetPlane(iplane)->GetPitchX(),
		    GetPlane(iplane)->GetPitchY(),
		    GetPlane(iplane)->GetZdimension(),
		    GetPlane(iplane)->GetNoiseElectrons(),
		    GetPlane(iplane)->GetTemperature(),
		    GetADC(iadc)->GetNbits(),
		    GetADC(iadc)->GetADC_linear(),
		    GetADC(iadc)->GetLSB(),
		    GetADC(iadc)->GetElectron_Conversion(),
		    GetTransport(itransport)->GetChargeModel())
	      ;	    
	    std::cout<<charac;
	    iconfigcounter++;
	  }
	}
      }
    }
    std::cout<<"num |Thet|Phi |Pit x X y|epi |Nois|Temp|Nbits|lin|LSB  |gain   |Model|"<<endl;
    std::cout<<"************************************************************** "<<endl;


}
//______________________________________________________________________________
//  
void  DIGMAPS::InspectEvent(Int_t EventNumber)
{
  DIGAction *myAction = GetAction();
  Char_t *myDoit = myAction->GetDoit();  
  Int_t myIntAction = 0;
  Char_t action2[200] = "plot";
  if(!std::strncmp( action2, myDoit,strlen(action2))  ){
    cout<<" WE CAN PLOT THAT !"<<endl;
    myIntAction=2;
  }else{
    cout<<" No action plot done before !"<<endl;
    return;
  }

  cout<<" Event number "<<EventNumber <<"is observed"<<endl;


  delete myAction;
  delete myDoit;

}
//______________________________________________________________________________
//  
void  DIGMAPS::RunConfiguration(Int_t configcounter, Int_t BeamNumber, Int_t PlaneNumber, Int_t ADCNumber, Int_t TransportNumber) 
{ 
  //compute visible surface.
  //compute active length, xlength, Y length, output position.

  //----compute density parameters
  //total surface in um^2
  Float_t totalsurface = (GetPlane(PlaneNumber)-> GetXdimension()) *  (GetPlane(PlaneNumber)-> GetYdimension());
  //  Compute Lambda value of the Poisson law for a given surface:
  Float_t Lambda_poisson = totalsurface * 0.000001 *  (GetBeam(BeamNumber)->GetParticleDensity());
  Double_t xran,yran,zran;


  GlobalSeed++;
  TRandom3 *r3 = new TRandom3(GlobalSeed);

  Int_t NumberOfEvents = GetBeam(BeamNumber)->GetNumberOfEvents();
  //-------------------------------------------------------------------------------------
  //--------------Loop on events.
  //-------------------------------------------------------------------------------------
  DIGParticle *fdigparticle=0;
  //DIGReadoutmap *fdigreadoutmap=0;
  for (Int_t iEvent = 0; iEvent < NumberOfEvents ; iEvent++){ 
    fdigevent = new DIGEvent();
    //---generate incident particles.
    Int_t numberofparticles = 0;
    if(GetBeam(BeamNumber)->GetBeamOption()==1){
      numberofparticles = PoissonLaw( Lambda_poisson);
    }else{
      numberofparticles=1;
    }

    std::cout<<"-----event "<<iEvent<<" with "<<numberofparticles<<" particles produced"<<endl;
    //---------------------------------------------
    //--------------Loop on  particles
    //---------------------------------------------
    for (Int_t ipart = 0; ipart < numberofparticles ; ipart++){ 
      
      //---------Energy deposition generation
      //Energy in e-:
      Float_t Energy = LandauLaw(860.0,180.0);
      while(Energy>20000){
	cout<<"Energy too high -> Energy regenerated"<<Energy<<endl;
	Energy = LandauLaw(860.0,180.0);
      }
      //scale Energy with epitaxial thickness
      //Energy = Energy * GetPlane(PlaneNumber)->GetZdimension() / 10.0;
      //scale with incident angle
      Float_t mtotallentgh = (GetPlane(PlaneNumber)->GetZdimension())
	/ TMath::Cos((GetBeam(BeamNumber)->GetThetaIncidentDeg())*PI/180.0);
      Energy = Energy * mtotallentgh / 10.0;
      

      //compute random entry point:
      if(GetBeam(BeamNumber)->GetBeamOption()==1){
	xran = r3->Rndm()*(GetPlane(PlaneNumber)-> GetXdimension());
	yran = r3->Rndm()*(GetPlane(PlaneNumber)-> GetYdimension());
      }else{
	xran = (float(GetPlane(PlaneNumber)->GetNpixelsX()/2) + r3->Rndm() )* (GetPlane(PlaneNumber)->GetPitchX());
 	yran = (float(GetPlane(PlaneNumber)->GetNpixelsY()/2) + r3->Rndm() )* (GetPlane(PlaneNumber)->GetPitchY());
     }
      zran=0.0;
      Float_t thetapos = GetBeam(BeamNumber)->GetThetaIncidentDeg();
      Float_t phipos = GetBeam(BeamNumber)->GetPhiIncidentDeg();//r3->Rndm()*360.0;
      Float_t thetaposrad = thetapos*PI/180.0;
      Float_t phiposrad = phipos*PI/180.0;
      //compute exit position given the incident angle:
      Float_t totalXlength=(GetPlane(PlaneNumber)->GetZdimension()) *TMath::Tan(thetaposrad)*TMath::Cos(phiposrad);
      Float_t totalYlength=(GetPlane(PlaneNumber)->GetZdimension()) *TMath::Tan(thetaposrad)*TMath::Sin(phiposrad);
      Float_t outputXpos=xran+totalXlength;
      Float_t outputYpos=yran+totalYlength;
      Float_t outputZpos=(GetPlane(PlaneNumber)->GetZdimension());
      
      fdigparticle = new DIGParticle(xran,yran,zran,outputXpos,outputYpos,outputZpos,Energy);
      //---------charge generation
      fdigparticle->ComputeChargeDeposition(GetPlane(PlaneNumber)->GetSegmentSize(), 
		       GetPlane(PlaneNumber)->GetMaximumSegmentSize(),
		       GetPlane(PlaneNumber)->GetMaximumChargePerSegment());
      //---------charge transport
      fdigparticle->ComputeChargeTransport(GetPlane(PlaneNumber),GetTransport(TransportNumber));
      //---------random noise (should be removed if one wants to avoid double noise on double hit pixels)
      fdigparticle->AddRandomNoise(GetPlane(PlaneNumber));
      //---------ADC (stored only for reference)
      fdigparticle->AnalogToDigitalconversion(GetADC(ADCNumber), GetPlane(PlaneNumber) );
      //fdigparticle->PrintInfo();
      //---------Add particle to fDIGParticleArray:
      //cout<<" TESTT 0 1 "<<ipart<<endl;
      fdigevent->AddParticle(*fdigparticle);
      std::vector<Float_t> chargevector;
      std::vector<Int_t> pixmapvector;
      chargevector = fdigparticle->GetAnalogCharge();
      pixmapvector = fdigparticle->GetPixelMap();
      for (Int_t ipix=0 ; ipix<fdigparticle->GetNpixels() ; ipix++){
	(fdigevent->GetReadoutmap())->UpdatePixel(chargevector[ipix], pixmapvector[ipix]);	
      }
      //fdigparticle->Clear();
      delete fdigparticle;      
    }
    //---------------------------------------------
    //----------end loop on particles
    //---------------------------------------------
    // fdigevent->PrintInfo();
 
    //---------Build readout map:
    (fdigevent->GetReadoutmap())->AnalogToDigitalconversion(GetADC(ADCNumber), GetPlane(PlaneNumber));
     //---------Build clusters:
    fdigevent->BuildTrueClusters(GetPlane(PlaneNumber));
    fdigevent->SetConfigurationNumber(configcounter);
    //---------Print Info on event if needed
    //fdigevent->PrintInfo();
    //---------P
    TClonesArray *particules   = fdigevent->GetParticle();
    if( fdigevent->GetNParticles() != (particules->GetLast()+1)){
      cout<< "DIGMAPS 4::PrintInfo WARNING PROBLEM IN PARTICLES RECORDING"<<endl;
    }
    //--------- store event.
    fdigbeam  = (DIGBeam*)GetBeam(BeamNumber)->Clone();
    fdigplane = (DIGPlane*)GetPlane(PlaneNumber)->Clone();
    fdigadc   = (DIGADC*)GetADC(ADCNumber)->Clone();
    ftree->Fill();
  } //end loop on events
  
  delete r3;
}
//______________________________________________________________________________
//  
void  DIGMAPS::ChargeGeneration(DIGParticle& aDIGParticle, Float_t StartingSegmentSize, Float_t MaximumSegmentSize,
					  Float_t MaximumChargePerSegment) 
{ 
  aDIGParticle.ComputeChargeDeposition(StartingSegmentSize, MaximumSegmentSize,MaximumChargePerSegment) ;
}
//______________________________________________________________________________
//  
Int_t  DIGMAPS::PoissonLaw(Float_t Lambda) 
{ 
  Int_t n;
  GlobalSeed++;
  TRandom3 *r3 = new TRandom3(GlobalSeed);
  //Float_t smear = r3->Rndm(245);
  n = r3->Poisson(Lambda);

  //  TMath::PoissonI(x,Lambda)
  delete r3;
  return n;
    
}
//______________________________________________________________________________
//  
Double_t  DIGMAPS::LandauLaw(Double_t mean, Double_t sigma) 
{ 
  Double_t x;
  GlobalSeed++;
  TRandom3 *r3 = new TRandom3(GlobalSeed);
  //Float_t smear = r3->Rndm(245);
  x = r3->Landau(mean,sigma);
  //  TMath::PoissonI(x,Lambda)
  delete r3;
  return x;
}
//______________________________________________________________________________
//  
Double_t  DIGMAPS::GaussianLaw(Double_t mean, Double_t sigma) 
{ 
  Double_t x;
  GlobalSeed++;
  TRandom3 *r3 = new TRandom3(GlobalSeed);
  //Float_t smear = r3->Rndm(245);
  x = r3->Gaus(mean,sigma);
  //  TMath::PoissonI(x,Lambda)
  delete r3;
  return x;
}
//_______________________________________________________________________________________
//
  Double_t DIGMAPS::Lorentz2D(Double_t *x, Double_t *par){ 
    //x[0] = x
    //x[1] = y
    // par[0] = Gamma
    // par[1] = x0
    // par[2] = y0
    // par[3] = norm
  if(par[0]>0){
    Double_t Pi = 3.141592653;
    return par[3]*par[0]/Pi/((x[0]-par[1])*(x[0]-par[1])+(x[1]-par[2])*(x[1]-par[2])+par[0]*par[0]) ; 
  }else{
    return 0;
  }
}
//______________________________________________________________________________
//  
void  DIGMAPS::SetfAction(TString action)
{
  fAction = action;
}

//______________________________________________________________________________
//  
void  DIGMAPS::SetIsOutputfile(Bool_t IsOutputfile)
{
  fIsOutputfile = IsOutputfile;
}
//______________________________________________________________________________
//  
void  DIGMAPS::SetAction(DIGAction *aDIGAction)
{ 
  fDIGAction = aDIGAction;
}
//______________________________________________________________________________
//  
void  DIGMAPS::SetNumberOfConfigurations(Int_t NumberOfConfiguration)
{ 
  fNumberOfConfigurations = NumberOfConfiguration;
}
//______________________________________________________________________________
//  
void  DIGMAPS::SetConfigPath(TString aCP) 
{ 
  fConfigPath = aCP;  
}


//______________________________________________________________________________
//  
void DIGMAPS::SetConfigFileName(TString aCFN) 
{ 
  fConfigFileName = aCFN;     
} 

//______________________________________________________________________________
//  
void DIGMAPS::SetConfigPathAndFileName() 
{ 
  fConfigPathAndFileName = fConfigPath + fConfigFileName;     
} 

//______________________________________________________________________________
//  
void DIGMAPS::SetConfigPathAndFileName(TString aCP,TString aCFN) 
{ 
  fConfigPath = aCP;  
  fConfigFileName = aCFN;     
  fConfigPathAndFileName = fConfigPath + fConfigFileName;  
} 
//______________________________________________________________________________
//  
TString  DIGMAPS::GetConfigPath() 
{ 
  return fConfigPath;  
}
//______________________________________________________________________________
//  
TString DIGMAPS::GetConfigFileName() 
{ 
  return fConfigFileName;     
} 
//______________________________________________________________________________
//  
TString DIGMAPS::GetConfigPathAndFileName() 
{ 
  return fConfigPathAndFileName;
} 







//______________________________________________________________________________
//  
void  DIGMAPS::SetOutputPath(TString outp) 
{ 
  fOutputPath = outp;  
 
}


//______________________________________________________________________________
//  
void DIGMAPS::SetOutputFileName(TString outf) 
{ 
  fOutputFileName = outf;     
} 

//______________________________________________________________________________
//  
void DIGMAPS::SetOutputPathAndFileName() 
{ 
  fOutputPathAndFileName = fOutputPath + fOutputFileName;     
} 

//______________________________________________________________________________
//  
void DIGMAPS::SetOutputPathAndFileName(TString outp,TString outf) 
{ 
  fOutputPath = outp;  
  fOutputFileName = outf;     
  fOutputPathAndFileName = fOutputPath + fOutputFileName;  
} 




//______________________________________________________________________________
//  
DIGPlane* DIGMAPS::GetPlane(Int_t aPlaneNumber){
  return (DIGPlane*)fDIGPlaneArray->At(aPlaneNumber);
}
//______________________________________________________________________________
//  
DIGADC* DIGMAPS::GetADC(Int_t anADCNumber){
  return (DIGADC*)fDIGADCArray->At(anADCNumber);
}
//______________________________________________________________________________
//  
DIGTransport* DIGMAPS::GetTransport(Int_t aTransportNumber){
  return (DIGTransport*)fDIGTransportArray->At(aTransportNumber);
}
//______________________________________________________________________________
//  
DIGBeam* DIGMAPS::GetBeam(Int_t aBeamNumber){
  return (DIGBeam*)fDIGBeamArray->At(aBeamNumber);
}
//______________________________________________________________________________
//  
void   DIGMAPS::ReadTree(TString StringTree){

  cout<<StringTree<<endl;

}

 digmaps.cxx:1
 digmaps.cxx:2
 digmaps.cxx:3
 digmaps.cxx:4
 digmaps.cxx:5
 digmaps.cxx:6
 digmaps.cxx:7
 digmaps.cxx:8
 digmaps.cxx:9
 digmaps.cxx:10
 digmaps.cxx:11
 digmaps.cxx:12
 digmaps.cxx:13
 digmaps.cxx:14
 digmaps.cxx:15
 digmaps.cxx:16
 digmaps.cxx:17
 digmaps.cxx:18
 digmaps.cxx:19
 digmaps.cxx:20
 digmaps.cxx:21
 digmaps.cxx:22
 digmaps.cxx:23
 digmaps.cxx:24
 digmaps.cxx:25
 digmaps.cxx:26
 digmaps.cxx:27
 digmaps.cxx:28
 digmaps.cxx:29
 digmaps.cxx:30
 digmaps.cxx:31
 digmaps.cxx:32
 digmaps.cxx:33
 digmaps.cxx:34
 digmaps.cxx:35
 digmaps.cxx:36
 digmaps.cxx:37
 digmaps.cxx:38
 digmaps.cxx:39
 digmaps.cxx:40
 digmaps.cxx:41
 digmaps.cxx:42
 digmaps.cxx:43
 digmaps.cxx:44
 digmaps.cxx:45
 digmaps.cxx:46
 digmaps.cxx:47
 digmaps.cxx:48
 digmaps.cxx:49
 digmaps.cxx:50
 digmaps.cxx:51
 digmaps.cxx:52
 digmaps.cxx:53
 digmaps.cxx:54
 digmaps.cxx:55
 digmaps.cxx:56
 digmaps.cxx:57
 digmaps.cxx:58
 digmaps.cxx:59
 digmaps.cxx:60
 digmaps.cxx:61
 digmaps.cxx:62
 digmaps.cxx:63
 digmaps.cxx:64
 digmaps.cxx:65
 digmaps.cxx:66
 digmaps.cxx:67
 digmaps.cxx:68
 digmaps.cxx:69
 digmaps.cxx:70
 digmaps.cxx:71
 digmaps.cxx:72
 digmaps.cxx:73
 digmaps.cxx:74
 digmaps.cxx:75
 digmaps.cxx:76
 digmaps.cxx:77
 digmaps.cxx:78
 digmaps.cxx:79
 digmaps.cxx:80
 digmaps.cxx:81
 digmaps.cxx:82
 digmaps.cxx:83
 digmaps.cxx:84
 digmaps.cxx:85
 digmaps.cxx:86
 digmaps.cxx:87
 digmaps.cxx:88
 digmaps.cxx:89
 digmaps.cxx:90
 digmaps.cxx:91
 digmaps.cxx:92
 digmaps.cxx:93
 digmaps.cxx:94
 digmaps.cxx:95
 digmaps.cxx:96
 digmaps.cxx:97
 digmaps.cxx:98
 digmaps.cxx:99
 digmaps.cxx:100
 digmaps.cxx:101
 digmaps.cxx:102
 digmaps.cxx:103
 digmaps.cxx:104
 digmaps.cxx:105
 digmaps.cxx:106
 digmaps.cxx:107
 digmaps.cxx:108
 digmaps.cxx:109
 digmaps.cxx:110
 digmaps.cxx:111
 digmaps.cxx:112
 digmaps.cxx:113
 digmaps.cxx:114
 digmaps.cxx:115
 digmaps.cxx:116
 digmaps.cxx:117
 digmaps.cxx:118
 digmaps.cxx:119
 digmaps.cxx:120
 digmaps.cxx:121
 digmaps.cxx:122
 digmaps.cxx:123
 digmaps.cxx:124
 digmaps.cxx:125
 digmaps.cxx:126
 digmaps.cxx:127
 digmaps.cxx:128
 digmaps.cxx:129
 digmaps.cxx:130
 digmaps.cxx:131
 digmaps.cxx:132
 digmaps.cxx:133
 digmaps.cxx:134
 digmaps.cxx:135
 digmaps.cxx:136
 digmaps.cxx:137
 digmaps.cxx:138
 digmaps.cxx:139
 digmaps.cxx:140
 digmaps.cxx:141
 digmaps.cxx:142
 digmaps.cxx:143
 digmaps.cxx:144
 digmaps.cxx:145
 digmaps.cxx:146
 digmaps.cxx:147
 digmaps.cxx:148
 digmaps.cxx:149
 digmaps.cxx:150
 digmaps.cxx:151
 digmaps.cxx:152
 digmaps.cxx:153
 digmaps.cxx:154
 digmaps.cxx:155
 digmaps.cxx:156
 digmaps.cxx:157
 digmaps.cxx:158
 digmaps.cxx:159
 digmaps.cxx:160
 digmaps.cxx:161
 digmaps.cxx:162
 digmaps.cxx:163
 digmaps.cxx:164
 digmaps.cxx:165
 digmaps.cxx:166
 digmaps.cxx:167
 digmaps.cxx:168
 digmaps.cxx:169
 digmaps.cxx:170
 digmaps.cxx:171
 digmaps.cxx:172
 digmaps.cxx:173
 digmaps.cxx:174
 digmaps.cxx:175
 digmaps.cxx:176
 digmaps.cxx:177
 digmaps.cxx:178
 digmaps.cxx:179
 digmaps.cxx:180
 digmaps.cxx:181
 digmaps.cxx:182
 digmaps.cxx:183
 digmaps.cxx:184
 digmaps.cxx:185
 digmaps.cxx:186
 digmaps.cxx:187
 digmaps.cxx:188
 digmaps.cxx:189
 digmaps.cxx:190
 digmaps.cxx:191
 digmaps.cxx:192
 digmaps.cxx:193
 digmaps.cxx:194
 digmaps.cxx:195
 digmaps.cxx:196
 digmaps.cxx:197
 digmaps.cxx:198
 digmaps.cxx:199
 digmaps.cxx:200
 digmaps.cxx:201
 digmaps.cxx:202
 digmaps.cxx:203
 digmaps.cxx:204
 digmaps.cxx:205
 digmaps.cxx:206
 digmaps.cxx:207
 digmaps.cxx:208
 digmaps.cxx:209
 digmaps.cxx:210
 digmaps.cxx:211
 digmaps.cxx:212
 digmaps.cxx:213
 digmaps.cxx:214
 digmaps.cxx:215
 digmaps.cxx:216
 digmaps.cxx:217
 digmaps.cxx:218
 digmaps.cxx:219
 digmaps.cxx:220
 digmaps.cxx:221
 digmaps.cxx:222
 digmaps.cxx:223
 digmaps.cxx:224
 digmaps.cxx:225
 digmaps.cxx:226
 digmaps.cxx:227
 digmaps.cxx:228
 digmaps.cxx:229
 digmaps.cxx:230
 digmaps.cxx:231
 digmaps.cxx:232
 digmaps.cxx:233
 digmaps.cxx:234
 digmaps.cxx:235
 digmaps.cxx:236
 digmaps.cxx:237
 digmaps.cxx:238
 digmaps.cxx:239
 digmaps.cxx:240
 digmaps.cxx:241
 digmaps.cxx:242
 digmaps.cxx:243
 digmaps.cxx:244
 digmaps.cxx:245
 digmaps.cxx:246
 digmaps.cxx:247
 digmaps.cxx:248
 digmaps.cxx:249
 digmaps.cxx:250
 digmaps.cxx:251
 digmaps.cxx:252
 digmaps.cxx:253
 digmaps.cxx:254
 digmaps.cxx:255
 digmaps.cxx:256
 digmaps.cxx:257
 digmaps.cxx:258
 digmaps.cxx:259
 digmaps.cxx:260
 digmaps.cxx:261
 digmaps.cxx:262
 digmaps.cxx:263
 digmaps.cxx:264
 digmaps.cxx:265
 digmaps.cxx:266
 digmaps.cxx:267
 digmaps.cxx:268
 digmaps.cxx:269
 digmaps.cxx:270
 digmaps.cxx:271
 digmaps.cxx:272
 digmaps.cxx:273
 digmaps.cxx:274
 digmaps.cxx:275
 digmaps.cxx:276
 digmaps.cxx:277
 digmaps.cxx:278
 digmaps.cxx:279
 digmaps.cxx:280
 digmaps.cxx:281
 digmaps.cxx:282
 digmaps.cxx:283
 digmaps.cxx:284
 digmaps.cxx:285
 digmaps.cxx:286
 digmaps.cxx:287
 digmaps.cxx:288
 digmaps.cxx:289
 digmaps.cxx:290
 digmaps.cxx:291
 digmaps.cxx:292
 digmaps.cxx:293
 digmaps.cxx:294
 digmaps.cxx:295
 digmaps.cxx:296
 digmaps.cxx:297
 digmaps.cxx:298
 digmaps.cxx:299
 digmaps.cxx:300
 digmaps.cxx:301
 digmaps.cxx:302
 digmaps.cxx:303
 digmaps.cxx:304
 digmaps.cxx:305
 digmaps.cxx:306
 digmaps.cxx:307
 digmaps.cxx:308
 digmaps.cxx:309
 digmaps.cxx:310
 digmaps.cxx:311
 digmaps.cxx:312
 digmaps.cxx:313
 digmaps.cxx:314
 digmaps.cxx:315
 digmaps.cxx:316
 digmaps.cxx:317
 digmaps.cxx:318
 digmaps.cxx:319
 digmaps.cxx:320
 digmaps.cxx:321
 digmaps.cxx:322
 digmaps.cxx:323
 digmaps.cxx:324
 digmaps.cxx:325
 digmaps.cxx:326
 digmaps.cxx:327
 digmaps.cxx:328
 digmaps.cxx:329
 digmaps.cxx:330
 digmaps.cxx:331
 digmaps.cxx:332
 digmaps.cxx:333
 digmaps.cxx:334
 digmaps.cxx:335
 digmaps.cxx:336
 digmaps.cxx:337
 digmaps.cxx:338
 digmaps.cxx:339
 digmaps.cxx:340
 digmaps.cxx:341
 digmaps.cxx:342
 digmaps.cxx:343
 digmaps.cxx:344
 digmaps.cxx:345
 digmaps.cxx:346
 digmaps.cxx:347
 digmaps.cxx:348
 digmaps.cxx:349
 digmaps.cxx:350
 digmaps.cxx:351
 digmaps.cxx:352
 digmaps.cxx:353
 digmaps.cxx:354
 digmaps.cxx:355
 digmaps.cxx:356
 digmaps.cxx:357
 digmaps.cxx:358
 digmaps.cxx:359
 digmaps.cxx:360
 digmaps.cxx:361
 digmaps.cxx:362
 digmaps.cxx:363
 digmaps.cxx:364
 digmaps.cxx:365
 digmaps.cxx:366
 digmaps.cxx:367
 digmaps.cxx:368
 digmaps.cxx:369
 digmaps.cxx:370
 digmaps.cxx:371
 digmaps.cxx:372
 digmaps.cxx:373
 digmaps.cxx:374
 digmaps.cxx:375
 digmaps.cxx:376
 digmaps.cxx:377
 digmaps.cxx:378
 digmaps.cxx:379
 digmaps.cxx:380
 digmaps.cxx:381
 digmaps.cxx:382
 digmaps.cxx:383
 digmaps.cxx:384
 digmaps.cxx:385
 digmaps.cxx:386
 digmaps.cxx:387
 digmaps.cxx:388
 digmaps.cxx:389
 digmaps.cxx:390
 digmaps.cxx:391
 digmaps.cxx:392
 digmaps.cxx:393
 digmaps.cxx:394
 digmaps.cxx:395
 digmaps.cxx:396
 digmaps.cxx:397
 digmaps.cxx:398
 digmaps.cxx:399
 digmaps.cxx:400
 digmaps.cxx:401
 digmaps.cxx:402
 digmaps.cxx:403
 digmaps.cxx:404
 digmaps.cxx:405
 digmaps.cxx:406
 digmaps.cxx:407
 digmaps.cxx:408
 digmaps.cxx:409
 digmaps.cxx:410
 digmaps.cxx:411
 digmaps.cxx:412
 digmaps.cxx:413
 digmaps.cxx:414
 digmaps.cxx:415
 digmaps.cxx:416
 digmaps.cxx:417
 digmaps.cxx:418
 digmaps.cxx:419
 digmaps.cxx:420
 digmaps.cxx:421
 digmaps.cxx:422
 digmaps.cxx:423
 digmaps.cxx:424
 digmaps.cxx:425
 digmaps.cxx:426
 digmaps.cxx:427
 digmaps.cxx:428
 digmaps.cxx:429
 digmaps.cxx:430
 digmaps.cxx:431
 digmaps.cxx:432
 digmaps.cxx:433
 digmaps.cxx:434
 digmaps.cxx:435
 digmaps.cxx:436
 digmaps.cxx:437
 digmaps.cxx:438
 digmaps.cxx:439
 digmaps.cxx:440
 digmaps.cxx:441
 digmaps.cxx:442
 digmaps.cxx:443
 digmaps.cxx:444
 digmaps.cxx:445
 digmaps.cxx:446
 digmaps.cxx:447
 digmaps.cxx:448
 digmaps.cxx:449
 digmaps.cxx:450
 digmaps.cxx:451
 digmaps.cxx:452
 digmaps.cxx:453
 digmaps.cxx:454
 digmaps.cxx:455
 digmaps.cxx:456
 digmaps.cxx:457
 digmaps.cxx:458
 digmaps.cxx:459
 digmaps.cxx:460
 digmaps.cxx:461
 digmaps.cxx:462
 digmaps.cxx:463
 digmaps.cxx:464
 digmaps.cxx:465
 digmaps.cxx:466
 digmaps.cxx:467
 digmaps.cxx:468
 digmaps.cxx:469
 digmaps.cxx:470
 digmaps.cxx:471
 digmaps.cxx:472
 digmaps.cxx:473
 digmaps.cxx:474
 digmaps.cxx:475
 digmaps.cxx:476
 digmaps.cxx:477
 digmaps.cxx:478
 digmaps.cxx:479
 digmaps.cxx:480
 digmaps.cxx:481
 digmaps.cxx:482
 digmaps.cxx:483
 digmaps.cxx:484
 digmaps.cxx:485
 digmaps.cxx:486
 digmaps.cxx:487
 digmaps.cxx:488
 digmaps.cxx:489
 digmaps.cxx:490
 digmaps.cxx:491
 digmaps.cxx:492
 digmaps.cxx:493
 digmaps.cxx:494
 digmaps.cxx:495
 digmaps.cxx:496
 digmaps.cxx:497
 digmaps.cxx:498
 digmaps.cxx:499
 digmaps.cxx:500
 digmaps.cxx:501
 digmaps.cxx:502
 digmaps.cxx:503
 digmaps.cxx:504
 digmaps.cxx:505
 digmaps.cxx:506
 digmaps.cxx:507
 digmaps.cxx:508
 digmaps.cxx:509
 digmaps.cxx:510
 digmaps.cxx:511
 digmaps.cxx:512
 digmaps.cxx:513
 digmaps.cxx:514
 digmaps.cxx:515
 digmaps.cxx:516
 digmaps.cxx:517
 digmaps.cxx:518
 digmaps.cxx:519
 digmaps.cxx:520
 digmaps.cxx:521
 digmaps.cxx:522
 digmaps.cxx:523
 digmaps.cxx:524
 digmaps.cxx:525
 digmaps.cxx:526
 digmaps.cxx:527
 digmaps.cxx:528
 digmaps.cxx:529
 digmaps.cxx:530
 digmaps.cxx:531
 digmaps.cxx:532
 digmaps.cxx:533
 digmaps.cxx:534
 digmaps.cxx:535
 digmaps.cxx:536
 digmaps.cxx:537
 digmaps.cxx:538
 digmaps.cxx:539
 digmaps.cxx:540
 digmaps.cxx:541
 digmaps.cxx:542
 digmaps.cxx:543
 digmaps.cxx:544
 digmaps.cxx:545
 digmaps.cxx:546
 digmaps.cxx:547
 digmaps.cxx:548
 digmaps.cxx:549
 digmaps.cxx:550
 digmaps.cxx:551
 digmaps.cxx:552
 digmaps.cxx:553
 digmaps.cxx:554
 digmaps.cxx:555
 digmaps.cxx:556
 digmaps.cxx:557
 digmaps.cxx:558
 digmaps.cxx:559
 digmaps.cxx:560
 digmaps.cxx:561
 digmaps.cxx:562
 digmaps.cxx:563
 digmaps.cxx:564
 digmaps.cxx:565
 digmaps.cxx:566
 digmaps.cxx:567
 digmaps.cxx:568
 digmaps.cxx:569
 digmaps.cxx:570
 digmaps.cxx:571
 digmaps.cxx:572
 digmaps.cxx:573
 digmaps.cxx:574
 digmaps.cxx:575
 digmaps.cxx:576
 digmaps.cxx:577
 digmaps.cxx:578
 digmaps.cxx:579
 digmaps.cxx:580
 digmaps.cxx:581
 digmaps.cxx:582
 digmaps.cxx:583
 digmaps.cxx:584
 digmaps.cxx:585
 digmaps.cxx:586
 digmaps.cxx:587
 digmaps.cxx:588
 digmaps.cxx:589
 digmaps.cxx:590
 digmaps.cxx:591
 digmaps.cxx:592
 digmaps.cxx:593
 digmaps.cxx:594
 digmaps.cxx:595
 digmaps.cxx:596
 digmaps.cxx:597
 digmaps.cxx:598
 digmaps.cxx:599
 digmaps.cxx:600
 digmaps.cxx:601
 digmaps.cxx:602
 digmaps.cxx:603
 digmaps.cxx:604
 digmaps.cxx:605
 digmaps.cxx:606
 digmaps.cxx:607
 digmaps.cxx:608
 digmaps.cxx:609
 digmaps.cxx:610
 digmaps.cxx:611
 digmaps.cxx:612
 digmaps.cxx:613
 digmaps.cxx:614
 digmaps.cxx:615
 digmaps.cxx:616
 digmaps.cxx:617
 digmaps.cxx:618
 digmaps.cxx:619
 digmaps.cxx:620
 digmaps.cxx:621
 digmaps.cxx:622
 digmaps.cxx:623
 digmaps.cxx:624
 digmaps.cxx:625
 digmaps.cxx:626
 digmaps.cxx:627
 digmaps.cxx:628
 digmaps.cxx:629
 digmaps.cxx:630
 digmaps.cxx:631
 digmaps.cxx:632
 digmaps.cxx:633
 digmaps.cxx:634
 digmaps.cxx:635
 digmaps.cxx:636
 digmaps.cxx:637
 digmaps.cxx:638
 digmaps.cxx:639
 digmaps.cxx:640
 digmaps.cxx:641
 digmaps.cxx:642
 digmaps.cxx:643
 digmaps.cxx:644
 digmaps.cxx:645
 digmaps.cxx:646
 digmaps.cxx:647
 digmaps.cxx:648
 digmaps.cxx:649
 digmaps.cxx:650
 digmaps.cxx:651
 digmaps.cxx:652
 digmaps.cxx:653
 digmaps.cxx:654
 digmaps.cxx:655
 digmaps.cxx:656
 digmaps.cxx:657
 digmaps.cxx:658
 digmaps.cxx:659
 digmaps.cxx:660
 digmaps.cxx:661
 digmaps.cxx:662
 digmaps.cxx:663
 digmaps.cxx:664
 digmaps.cxx:665
 digmaps.cxx:666
 digmaps.cxx:667
 digmaps.cxx:668
 digmaps.cxx:669
 digmaps.cxx:670
 digmaps.cxx:671
 digmaps.cxx:672
 digmaps.cxx:673
 digmaps.cxx:674
 digmaps.cxx:675
 digmaps.cxx:676
 digmaps.cxx:677
 digmaps.cxx:678
 digmaps.cxx:679
 digmaps.cxx:680
 digmaps.cxx:681
 digmaps.cxx:682
 digmaps.cxx:683
 digmaps.cxx:684
 digmaps.cxx:685
 digmaps.cxx:686
 digmaps.cxx:687
 digmaps.cxx:688
 digmaps.cxx:689
 digmaps.cxx:690
 digmaps.cxx:691
 digmaps.cxx:692
 digmaps.cxx:693
 digmaps.cxx:694
 digmaps.cxx:695
 digmaps.cxx:696
 digmaps.cxx:697
 digmaps.cxx:698
 digmaps.cxx:699
 digmaps.cxx:700
 digmaps.cxx:701
 digmaps.cxx:702
 digmaps.cxx:703
 digmaps.cxx:704
 digmaps.cxx:705
 digmaps.cxx:706
 digmaps.cxx:707
 digmaps.cxx:708
 digmaps.cxx:709
 digmaps.cxx:710
 digmaps.cxx:711
 digmaps.cxx:712
 digmaps.cxx:713
 digmaps.cxx:714
 digmaps.cxx:715
 digmaps.cxx:716
 digmaps.cxx:717
 digmaps.cxx:718
 digmaps.cxx:719
 digmaps.cxx:720
 digmaps.cxx:721
 digmaps.cxx:722
 digmaps.cxx:723
 digmaps.cxx:724
 digmaps.cxx:725
 digmaps.cxx:726
 digmaps.cxx:727
 digmaps.cxx:728
 digmaps.cxx:729
 digmaps.cxx:730
 digmaps.cxx:731
 digmaps.cxx:732
 digmaps.cxx:733
 digmaps.cxx:734
 digmaps.cxx:735
 digmaps.cxx:736
 digmaps.cxx:737
 digmaps.cxx:738
 digmaps.cxx:739
 digmaps.cxx:740
 digmaps.cxx:741
 digmaps.cxx:742
 digmaps.cxx:743
 digmaps.cxx:744
 digmaps.cxx:745
 digmaps.cxx:746
 digmaps.cxx:747
 digmaps.cxx:748
 digmaps.cxx:749
 digmaps.cxx:750
 digmaps.cxx:751
 digmaps.cxx:752
 digmaps.cxx:753
 digmaps.cxx:754
 digmaps.cxx:755
 digmaps.cxx:756
 digmaps.cxx:757
 digmaps.cxx:758
 digmaps.cxx:759
 digmaps.cxx:760
 digmaps.cxx:761
 digmaps.cxx:762
 digmaps.cxx:763
 digmaps.cxx:764
 digmaps.cxx:765
 digmaps.cxx:766
 digmaps.cxx:767
 digmaps.cxx:768
 digmaps.cxx:769
 digmaps.cxx:770
 digmaps.cxx:771
 digmaps.cxx:772
 digmaps.cxx:773
 digmaps.cxx:774
 digmaps.cxx:775
 digmaps.cxx:776
 digmaps.cxx:777
 digmaps.cxx:778
 digmaps.cxx:779
 digmaps.cxx:780
 digmaps.cxx:781
 digmaps.cxx:782
 digmaps.cxx:783
 digmaps.cxx:784
 digmaps.cxx:785
 digmaps.cxx:786
 digmaps.cxx:787
 digmaps.cxx:788
 digmaps.cxx:789
 digmaps.cxx:790
 digmaps.cxx:791
 digmaps.cxx:792
 digmaps.cxx:793
 digmaps.cxx:794
 digmaps.cxx:795
 digmaps.cxx:796
 digmaps.cxx:797
 digmaps.cxx:798
 digmaps.cxx:799
 digmaps.cxx:800
 digmaps.cxx:801
 digmaps.cxx:802
 digmaps.cxx:803
 digmaps.cxx:804
 digmaps.cxx:805
 digmaps.cxx:806
 digmaps.cxx:807
 digmaps.cxx:808
 digmaps.cxx:809
 digmaps.cxx:810
 digmaps.cxx:811
 digmaps.cxx:812
 digmaps.cxx:813
 digmaps.cxx:814
 digmaps.cxx:815
 digmaps.cxx:816
 digmaps.cxx:817
 digmaps.cxx:818
 digmaps.cxx:819
 digmaps.cxx:820
 digmaps.cxx:821
 digmaps.cxx:822
 digmaps.cxx:823
 digmaps.cxx:824
 digmaps.cxx:825
 digmaps.cxx:826
 digmaps.cxx:827
 digmaps.cxx:828
 digmaps.cxx:829
 digmaps.cxx:830
 digmaps.cxx:831
 digmaps.cxx:832
 digmaps.cxx:833
 digmaps.cxx:834
 digmaps.cxx:835
 digmaps.cxx:836
 digmaps.cxx:837
 digmaps.cxx:838
 digmaps.cxx:839
 digmaps.cxx:840
 digmaps.cxx:841
 digmaps.cxx:842
 digmaps.cxx:843
 digmaps.cxx:844
 digmaps.cxx:845
 digmaps.cxx:846
 digmaps.cxx:847
 digmaps.cxx:848
 digmaps.cxx:849
 digmaps.cxx:850
 digmaps.cxx:851
 digmaps.cxx:852
 digmaps.cxx:853
 digmaps.cxx:854
 digmaps.cxx:855
 digmaps.cxx:856
 digmaps.cxx:857
 digmaps.cxx:858
 digmaps.cxx:859
 digmaps.cxx:860
 digmaps.cxx:861
 digmaps.cxx:862
 digmaps.cxx:863
 digmaps.cxx:864
 digmaps.cxx:865
 digmaps.cxx:866
 digmaps.cxx:867
 digmaps.cxx:868
 digmaps.cxx:869
 digmaps.cxx:870
 digmaps.cxx:871
 digmaps.cxx:872
 digmaps.cxx:873
 digmaps.cxx:874
 digmaps.cxx:875
 digmaps.cxx:876
 digmaps.cxx:877
 digmaps.cxx:878
 digmaps.cxx:879
 digmaps.cxx:880
 digmaps.cxx:881
 digmaps.cxx:882
 digmaps.cxx:883
 digmaps.cxx:884
 digmaps.cxx:885
 digmaps.cxx:886
 digmaps.cxx:887
 digmaps.cxx:888
 digmaps.cxx:889
 digmaps.cxx:890
 digmaps.cxx:891
 digmaps.cxx:892
 digmaps.cxx:893
 digmaps.cxx:894
 digmaps.cxx:895
 digmaps.cxx:896
 digmaps.cxx:897
 digmaps.cxx:898
 digmaps.cxx:899
 digmaps.cxx:900
 digmaps.cxx:901
 digmaps.cxx:902
 digmaps.cxx:903
 digmaps.cxx:904
 digmaps.cxx:905
 digmaps.cxx:906
 digmaps.cxx:907
 digmaps.cxx:908
 digmaps.cxx:909
 digmaps.cxx:910
 digmaps.cxx:911
 digmaps.cxx:912
 digmaps.cxx:913
 digmaps.cxx:914
 digmaps.cxx:915
 digmaps.cxx:916
 digmaps.cxx:917
 digmaps.cxx:918
 digmaps.cxx:919
 digmaps.cxx:920
 digmaps.cxx:921
 digmaps.cxx:922
 digmaps.cxx:923
 digmaps.cxx:924
 digmaps.cxx:925
 digmaps.cxx:926
 digmaps.cxx:927
 digmaps.cxx:928
 digmaps.cxx:929
 digmaps.cxx:930
 digmaps.cxx:931
 digmaps.cxx:932
 digmaps.cxx:933
 digmaps.cxx:934
 digmaps.cxx:935
 digmaps.cxx:936
 digmaps.cxx:937
 digmaps.cxx:938
 digmaps.cxx:939
 digmaps.cxx:940
 digmaps.cxx:941
 digmaps.cxx:942
 digmaps.cxx:943
 digmaps.cxx:944
 digmaps.cxx:945
 digmaps.cxx:946
 digmaps.cxx:947
 digmaps.cxx:948
 digmaps.cxx:949
 digmaps.cxx:950
 digmaps.cxx:951
 digmaps.cxx:952
 digmaps.cxx:953
 digmaps.cxx:954
 digmaps.cxx:955
 digmaps.cxx:956
 digmaps.cxx:957
 digmaps.cxx:958
 digmaps.cxx:959
 digmaps.cxx:960
 digmaps.cxx:961
 digmaps.cxx:962
 digmaps.cxx:963
 digmaps.cxx:964
 digmaps.cxx:965
 digmaps.cxx:966
 digmaps.cxx:967
 digmaps.cxx:968
 digmaps.cxx:969
 digmaps.cxx:970
 digmaps.cxx:971
 digmaps.cxx:972
 digmaps.cxx:973
 digmaps.cxx:974
 digmaps.cxx:975
 digmaps.cxx:976
 digmaps.cxx:977
 digmaps.cxx:978
 digmaps.cxx:979
 digmaps.cxx:980
 digmaps.cxx:981
 digmaps.cxx:982
 digmaps.cxx:983
 digmaps.cxx:984
 digmaps.cxx:985
 digmaps.cxx:986
 digmaps.cxx:987
 digmaps.cxx:988
 digmaps.cxx:989
 digmaps.cxx:990
 digmaps.cxx:991
 digmaps.cxx:992
 digmaps.cxx:993
 digmaps.cxx:994
 digmaps.cxx:995
 digmaps.cxx:996
 digmaps.cxx:997
 digmaps.cxx:998
 digmaps.cxx:999
 digmaps.cxx:1000
 digmaps.cxx:1001
 digmaps.cxx:1002
 digmaps.cxx:1003
 digmaps.cxx:1004
 digmaps.cxx:1005
 digmaps.cxx:1006
 digmaps.cxx:1007
 digmaps.cxx:1008
 digmaps.cxx:1009
 digmaps.cxx:1010
 digmaps.cxx:1011
 digmaps.cxx:1012
 digmaps.cxx:1013
 digmaps.cxx:1014
 digmaps.cxx:1015
 digmaps.cxx:1016
 digmaps.cxx:1017
 digmaps.cxx:1018
 digmaps.cxx:1019
 digmaps.cxx:1020
 digmaps.cxx:1021
 digmaps.cxx:1022
 digmaps.cxx:1023
 digmaps.cxx:1024
 digmaps.cxx:1025
 digmaps.cxx:1026
 digmaps.cxx:1027
 digmaps.cxx:1028
 digmaps.cxx:1029
 digmaps.cxx:1030
 digmaps.cxx:1031
 digmaps.cxx:1032
 digmaps.cxx:1033
 digmaps.cxx:1034
 digmaps.cxx:1035
 digmaps.cxx:1036
 digmaps.cxx:1037
 digmaps.cxx:1038
 digmaps.cxx:1039
 digmaps.cxx:1040
 digmaps.cxx:1041
 digmaps.cxx:1042
 digmaps.cxx:1043
 digmaps.cxx:1044
 digmaps.cxx:1045
 digmaps.cxx:1046
 digmaps.cxx:1047
 digmaps.cxx:1048
 digmaps.cxx:1049
 digmaps.cxx:1050
 digmaps.cxx:1051
 digmaps.cxx:1052
 digmaps.cxx:1053
 digmaps.cxx:1054
 digmaps.cxx:1055
 digmaps.cxx:1056
 digmaps.cxx:1057
 digmaps.cxx:1058
 digmaps.cxx:1059
 digmaps.cxx:1060
 digmaps.cxx:1061
 digmaps.cxx:1062
 digmaps.cxx:1063
 digmaps.cxx:1064
 digmaps.cxx:1065
 digmaps.cxx:1066
 digmaps.cxx:1067
 digmaps.cxx:1068
 digmaps.cxx:1069
 digmaps.cxx:1070
 digmaps.cxx:1071
 digmaps.cxx:1072
 digmaps.cxx:1073
 digmaps.cxx:1074
 digmaps.cxx:1075
 digmaps.cxx:1076
 digmaps.cxx:1077
 digmaps.cxx:1078
 digmaps.cxx:1079
 digmaps.cxx:1080
 digmaps.cxx:1081
 digmaps.cxx:1082
 digmaps.cxx:1083
 digmaps.cxx:1084
 digmaps.cxx:1085
 digmaps.cxx:1086
 digmaps.cxx:1087
 digmaps.cxx:1088
 digmaps.cxx:1089
 digmaps.cxx:1090
 digmaps.cxx:1091
 digmaps.cxx:1092
 digmaps.cxx:1093
 digmaps.cxx:1094
 digmaps.cxx:1095
 digmaps.cxx:1096
 digmaps.cxx:1097
 digmaps.cxx:1098
 digmaps.cxx:1099
 digmaps.cxx:1100
 digmaps.cxx:1101
 digmaps.cxx:1102
 digmaps.cxx:1103
 digmaps.cxx:1104
 digmaps.cxx:1105
 digmaps.cxx:1106
 digmaps.cxx:1107
 digmaps.cxx:1108
 digmaps.cxx:1109
 digmaps.cxx:1110
 digmaps.cxx:1111
 digmaps.cxx:1112
 digmaps.cxx:1113
 digmaps.cxx:1114
 digmaps.cxx:1115
 digmaps.cxx:1116
 digmaps.cxx:1117
 digmaps.cxx:1118
 digmaps.cxx:1119
 digmaps.cxx:1120
 digmaps.cxx:1121
 digmaps.cxx:1122
 digmaps.cxx:1123
 digmaps.cxx:1124
 digmaps.cxx:1125
 digmaps.cxx:1126
 digmaps.cxx:1127
 digmaps.cxx:1128
 digmaps.cxx:1129
 digmaps.cxx:1130
 digmaps.cxx:1131
 digmaps.cxx:1132
 digmaps.cxx:1133
 digmaps.cxx:1134
 digmaps.cxx:1135
 digmaps.cxx:1136
 digmaps.cxx:1137
 digmaps.cxx:1138
 digmaps.cxx:1139
 digmaps.cxx:1140
 digmaps.cxx:1141
 digmaps.cxx:1142
 digmaps.cxx:1143
 digmaps.cxx:1144
 digmaps.cxx:1145
 digmaps.cxx:1146
 digmaps.cxx:1147
 digmaps.cxx:1148
 digmaps.cxx:1149
 digmaps.cxx:1150
 digmaps.cxx:1151
 digmaps.cxx:1152
 digmaps.cxx:1153
 digmaps.cxx:1154
 digmaps.cxx:1155
 digmaps.cxx:1156
 digmaps.cxx:1157
 digmaps.cxx:1158
 digmaps.cxx:1159
 digmaps.cxx:1160
 digmaps.cxx:1161
 digmaps.cxx:1162
 digmaps.cxx:1163
 digmaps.cxx:1164
 digmaps.cxx:1165
 digmaps.cxx:1166
 digmaps.cxx:1167
 digmaps.cxx:1168
 digmaps.cxx:1169
 digmaps.cxx:1170
 digmaps.cxx:1171
 digmaps.cxx:1172
 digmaps.cxx:1173
 digmaps.cxx:1174
 digmaps.cxx:1175
 digmaps.cxx:1176
 digmaps.cxx:1177
 digmaps.cxx:1178
 digmaps.cxx:1179
 digmaps.cxx:1180
 digmaps.cxx:1181
 digmaps.cxx:1182
 digmaps.cxx:1183
 digmaps.cxx:1184
 digmaps.cxx:1185
 digmaps.cxx:1186
 digmaps.cxx:1187
 digmaps.cxx:1188
 digmaps.cxx:1189
 digmaps.cxx:1190
 digmaps.cxx:1191
 digmaps.cxx:1192
 digmaps.cxx:1193
 digmaps.cxx:1194
 digmaps.cxx:1195
 digmaps.cxx:1196
 digmaps.cxx:1197
 digmaps.cxx:1198
 digmaps.cxx:1199
 digmaps.cxx:1200
 digmaps.cxx:1201
 digmaps.cxx:1202
 digmaps.cxx:1203
 digmaps.cxx:1204
 digmaps.cxx:1205
 digmaps.cxx:1206
 digmaps.cxx:1207
 digmaps.cxx:1208
 digmaps.cxx:1209
 digmaps.cxx:1210
 digmaps.cxx:1211
 digmaps.cxx:1212
 digmaps.cxx:1213
 digmaps.cxx:1214
 digmaps.cxx:1215
 digmaps.cxx:1216
 digmaps.cxx:1217
 digmaps.cxx:1218
 digmaps.cxx:1219
 digmaps.cxx:1220
 digmaps.cxx:1221
 digmaps.cxx:1222
 digmaps.cxx:1223
 digmaps.cxx:1224
 digmaps.cxx:1225
 digmaps.cxx:1226
 digmaps.cxx:1227
 digmaps.cxx:1228
 digmaps.cxx:1229
 digmaps.cxx:1230
 digmaps.cxx:1231
 digmaps.cxx:1232
 digmaps.cxx:1233
 digmaps.cxx:1234
 digmaps.cxx:1235
 digmaps.cxx:1236
 digmaps.cxx:1237
 digmaps.cxx:1238
 digmaps.cxx:1239
 digmaps.cxx:1240
 digmaps.cxx:1241
 digmaps.cxx:1242
 digmaps.cxx:1243
 digmaps.cxx:1244
 digmaps.cxx:1245
 digmaps.cxx:1246
 digmaps.cxx:1247
 digmaps.cxx:1248
 digmaps.cxx:1249
 digmaps.cxx:1250
 digmaps.cxx:1251
 digmaps.cxx:1252
 digmaps.cxx:1253
 digmaps.cxx:1254
 digmaps.cxx:1255
 digmaps.cxx:1256
 digmaps.cxx:1257
 digmaps.cxx:1258
 digmaps.cxx:1259
 digmaps.cxx:1260
 digmaps.cxx:1261
 digmaps.cxx:1262
 digmaps.cxx:1263
 digmaps.cxx:1264
 digmaps.cxx:1265
 digmaps.cxx:1266
 digmaps.cxx:1267
 digmaps.cxx:1268
 digmaps.cxx:1269
 digmaps.cxx:1270
 digmaps.cxx:1271
 digmaps.cxx:1272
 digmaps.cxx:1273
 digmaps.cxx:1274
 digmaps.cxx:1275
 digmaps.cxx:1276
 digmaps.cxx:1277
 digmaps.cxx:1278
 digmaps.cxx:1279
 digmaps.cxx:1280
 digmaps.cxx:1281
 digmaps.cxx:1282
 digmaps.cxx:1283
 digmaps.cxx:1284
 digmaps.cxx:1285
 digmaps.cxx:1286
 digmaps.cxx:1287
 digmaps.cxx:1288
 digmaps.cxx:1289
 digmaps.cxx:1290
 digmaps.cxx:1291
 digmaps.cxx:1292
 digmaps.cxx:1293
 digmaps.cxx:1294
 digmaps.cxx:1295
 digmaps.cxx:1296
 digmaps.cxx:1297
 digmaps.cxx:1298
 digmaps.cxx:1299
 digmaps.cxx:1300
 digmaps.cxx:1301
 digmaps.cxx:1302
 digmaps.cxx:1303
 digmaps.cxx:1304
 digmaps.cxx:1305
 digmaps.cxx:1306
 digmaps.cxx:1307
 digmaps.cxx:1308
 digmaps.cxx:1309
 digmaps.cxx:1310
 digmaps.cxx:1311
 digmaps.cxx:1312
 digmaps.cxx:1313
 digmaps.cxx:1314
 digmaps.cxx:1315
 digmaps.cxx:1316
 digmaps.cxx:1317
 digmaps.cxx:1318
 digmaps.cxx:1319
 digmaps.cxx:1320
 digmaps.cxx:1321
 digmaps.cxx:1322
 digmaps.cxx:1323
 digmaps.cxx:1324
 digmaps.cxx:1325
 digmaps.cxx:1326
 digmaps.cxx:1327
 digmaps.cxx:1328
 digmaps.cxx:1329
 digmaps.cxx:1330
 digmaps.cxx:1331
 digmaps.cxx:1332
 digmaps.cxx:1333
 digmaps.cxx:1334
 digmaps.cxx:1335
 digmaps.cxx:1336
 digmaps.cxx:1337
 digmaps.cxx:1338
 digmaps.cxx:1339
 digmaps.cxx:1340
 digmaps.cxx:1341
 digmaps.cxx:1342
 digmaps.cxx:1343
 digmaps.cxx:1344
 digmaps.cxx:1345
 digmaps.cxx:1346
 digmaps.cxx:1347
 digmaps.cxx:1348
 digmaps.cxx:1349
 digmaps.cxx:1350
 digmaps.cxx:1351
 digmaps.cxx:1352
 digmaps.cxx:1353
 digmaps.cxx:1354
 digmaps.cxx:1355
 digmaps.cxx:1356
 digmaps.cxx:1357
 digmaps.cxx:1358
 digmaps.cxx:1359
 digmaps.cxx:1360
 digmaps.cxx:1361
 digmaps.cxx:1362
 digmaps.cxx:1363
 digmaps.cxx:1364
 digmaps.cxx:1365
 digmaps.cxx:1366
 digmaps.cxx:1367
 digmaps.cxx:1368
 digmaps.cxx:1369
 digmaps.cxx:1370
 digmaps.cxx:1371
 digmaps.cxx:1372
 digmaps.cxx:1373
 digmaps.cxx:1374
 digmaps.cxx:1375
 digmaps.cxx:1376
 digmaps.cxx:1377