ROOT logo
// @(#)root/foam:$Name: not supported by cvs2svn $:$Id: PDEFoam.cxx 29246 2009-06-26 16:50:00Z brun $
// Authors: Tancredi Carli, Dominik Dannheim, Alexander Voigt

/**********************************************************************************
 * Project: TMVA - a Root-integrated toolkit for multivariate data analysis       *
 * Package: TMVA                                                                  *
 * Classes: PDEFoam, PDEFoamCell, PDEFoamIntegrand, PDEFoamMaxwt, PDEFoamVect,    *
 *          TFDISTR                                                               *
 * Web    : http://tmva.sourceforge.net                                           *
 *                                                                                *
 * Description:                                                                   *
 *      Implementations                                                           *
 *                                                                                *
 * Authors (alphabetical):                                                        *
 *      Tancredi Carli   - CERN, Switzerland                                      *
 *      Dominik Dannheim - CERN, Switzerland                                      *
 *      S. Jadach        - Institute of Nuclear Physics, Cracow, Poland           *
 *      Alexander Voigt  - CERN, Switzerland                                      *
 *      Peter Speckmayer - CERN, Switzerland                                      *
 *                                                                                * 
 * Copyright (c) 2008:                                                            *
 *      CERN, Switzerland                                                         * 
 *      MPI-K Heidelberg, Germany                                                 * 
 *                                                                                *
 * Redistribution and use in source and binary forms, with or without             *
 * modification, are permitted according to the terms listed in LICENSE           *
 * (http://tmva.sourceforge.net/LICENSE)                                          *
 **********************************************************************************/

//_______________________________________________________________________
//
// Implementation of PDEFoam
//
// The PDEFoam method is an
// extension of the PDERS method, which uses self-adapting binning to
// divide the multi-dimensional phase space in a finite number of
// hyper-rectangles (boxes).
//
// For a given number of boxes, the binning algorithm adjusts the size
// and position of the boxes inside the multidimensional phase space,
// minimizing the variance of the signal and background densities inside
// the boxes. The binned density information is stored in binary trees,
// allowing for a very fast and memory-efficient classification of
// events.
//
// The implementation of the PDEFoam is based on the monte-carlo
// integration package PDEFoam included in the analysis package ROOT.
//_______________________________________________________________________


#include <iostream>
#include <iomanip>
#include <fstream>
#include <sstream>
#include <assert.h>

#include "TMVA/Event.h"
#include "TMVA/Tools.h"
#include "TMVA/PDEFoam.h"
#include "TMVA/MsgLogger.h"
#include "TMVA/Types.h"

#include "TStyle.h"
#include "TObject.h"
#include "TH1.h"
#include "TMath.h"
#include "TVectorT.h"
#include "TRandom3.h"
#include "TRefArray.h"
#include "TMethodCall.h"
#include "G__ci.h"
#include "TColor.h"
#include "TSystem.h"

ClassImp(TMVA::PDEFoam)

static const Float_t gHigh= FLT_MAX;
static const Float_t gVlow=-FLT_MAX;

using namespace std;

#define SW2 setprecision(7) << setw(12)

//________________________________________________________________________________________________
TMVA::PDEFoam::PDEFoam() :
   fLogger(new MsgLogger("PDEFoam"))
{
   // Default constructor for streamer, user should not use it.
   fDim      = 0;
   fNoAct    = 0;
   fNCells   = 0;
   fRNmax    = 0;
   fMaskDiv  = 0;
   fInhiDiv  = 0;
   fXdivPRD  = 0;
   fCells    = 0;
   fAlpha    = 0;
   fCellsAct = 0;
   fPrimAcu  = 0;
   fHistEdg  = 0;
   fHistWt   = 0;
   fHistDbg  = 0;
   fMCMonit  = 0;
   fRho      = 0;  // Integrand function
   fMCvect   = 0;
   fRvec     = 0;
   fPseRan   = 0;  // generator of pseudorandom numbers

   fXmin      = 0;
   fXmax      = 0;
   fNElements = 0;
   fCutNmin   = kTRUE;
   fNmin      = 100;  // only used, when fCutMin == kTRUE
   fCutRMSmin = kFALSE;
   fRMSmin    = 1.0;

   SetPDEFoamVolumeFraction(-1.);

   fSignalClass     = -1;
   fBackgroundClass = -1;

   fDistr = new TFDISTR();
   fDistr->SetSignalClass( fSignalClass );
   fDistr->SetBackgroundClass( fBackgroundClass );

   fTimer = new Timer(fNCells, "PDEFoam", kTRUE);
   fVariableNames = new TObjArray();
}

//_________________________________________________________________________________________________
TMVA::PDEFoam::PDEFoam(const TString& Name) :
   fLogger(new MsgLogger("PDEFoam"))
{
   // User constructor, to be employed by the user

   if(strlen(Name)  >129) {
      Log() << kFATAL << "Name too long " << Name.Data() << Endl;
   }
   fName=Name;                                            // Class name
   fDate="  Release date:  2005.04.10";                   // Release date
   fVersion= "1.02M";                                     // Release version
   fMaskDiv  = 0;             // Dynamic Mask for  cell division, h-cubic
   fInhiDiv  = 0;             // Flag allowing to inhibit cell division in certain projection/edge
   fXdivPRD  = 0;             // Lists of division values encoded in one vector per direction
   fCells    = 0;
   fAlpha    = 0;
   fCellsAct = 0;
   fPrimAcu  = 0;
   fHistEdg  = 0;
   fHistWt   = 0;
   fHistDbg  = 0;
   fDim     = 0;                // dimension of hyp-cubical space
   fNCells   = 1000;             // Maximum number of Cells,    is usually re-set
   fNSampl   = 200;              // No of sampling when dividing cell
   fOptPRD   = 0;                // General Option switch for PRedefined Division, for quick check
   fOptDrive = 2;                // type of Drive =1,2 for TrueVol,Sigma,WtMax
   fChat     = 1;                // Chat=0,1,2 chat level in output, Chat=1 normal level
   fOptRej   = 1;                // OptRej=0, wted events; OptRej=1, wt=1 events
   //------------------------------------------------------
   fNBin     = 8;                // binning of edge-histogram in cell exploration
   fEvPerBin =25;                // maximum no. of EFFECTIVE event per bin, =0 option is inactive
   //------------------------------------------------------
   fNCalls = 0;                  // No of function calls
   fNEffev = 0;                  // Total no of eff. wt=1 events in build=up
   fLastCe =-1;                  // Index of the last cell
   fNoAct  = 0;                  // No of active cells (used in MC generation)
   fWtMin = gHigh;               // Minimal weight
   fWtMax = gVlow;               // Maximal weight
   fMaxWtRej =1.10;              // Maximum weight in rejection for getting wt=1 events
   fPseRan   = 0;                // Initialize private copy of random number generator
   fMCMonit  = 0;                // MC efficiency monitoring
   fRho = 0;                     // pointer to abstract class providing function to integrate
   fMethodCall=0;                // ROOT's pointer to global distribution function

   fXmin      = 0;
   fXmax      = 0;
   fCutNmin   = kFALSE;
   fCutRMSmin = kFALSE;
   SetPDEFoamVolumeFraction(-1.);

   fSignalClass     = -1;
   fBackgroundClass = -1;

   fDistr = new TFDISTR();
   fDistr->SetSignalClass( fSignalClass );
   fDistr->SetBackgroundClass( fBackgroundClass );

   fTimer = new Timer(fNCells, "PDEFoam", kTRUE);
   fVariableNames = new TObjArray();

   Log().SetSource( "PDEFoam" );
}

//_______________________________________________________________________________________________
TMVA::PDEFoam::~PDEFoam()
{
   delete fVariableNames;
   delete fTimer;
   delete fDistr;
   if (fXmin) delete [] fXmin;  fXmin=0; 
   if (fXmax) delete [] fXmax;  fXmax=0;

   // Default destructor
   Int_t i;

   if(fCells!= 0) {
      for(i=0; i<fNCells; i++) delete fCells[i]; // PDEFoamCell*[]
      delete [] fCells;
   }
   delete [] fRvec;    //double[]
   delete [] fAlpha;   //double[]
   delete [] fMCvect;  //double[]
   delete [] fPrimAcu; //double[]
   delete [] fMaskDiv; //int[]
   delete [] fInhiDiv; //int[]
 
   if( fXdivPRD!= 0) {
      for(i=0; i<fDim; i++) delete fXdivPRD[i]; // PDEFoamVect*[]
      delete [] fXdivPRD;
   }
   delete fMCMonit;
   delete fHistWt;

   delete fLogger;
}

//_____________________________________________________________________________________________
TMVA::PDEFoam::PDEFoam(const PDEFoam &From): 
   TObject(From),
   fLogger( new MsgLogger("PDEFoam"))
{
   // Copy Constructor  NOT IMPLEMENTED (NEVER USED)
   Log() << kFATAL << "COPY CONSTRUCTOR NOT IMPLEMENTED" << Endl;
}

//_______________________________________________________________________________________
void TMVA::PDEFoam::Initialize(Bool_t CreateCellElements)
{
   // Basic initialization of FOAM invoked by the user.
   // IMPORTANT: Random number generator and the distribution object has to be
   // provided using SetPseRan and SetRho prior to invoking this initializator!

   Bool_t addStatus = TH1::AddDirectoryStatus();
   TH1::AddDirectory(kFALSE);
   Int_t i;

   if(fPseRan==0) Log() << kFATAL << "Random number generator not set" << Endl;
   if(fRho==0 && fMethodCall==0 ) Log() << kFATAL << "Distribution function not set" << Endl;
   if(fDim==0) Log() << kFATAL << "Zero dimension not allowed" << Endl;

   /////////////////////////////////////////////////////////////////////////
   //                   ALLOCATE SMALL LISTS                              //
   //  it is done globally, not for each cell, to save on allocation time //
   /////////////////////////////////////////////////////////////////////////
   fRNmax= fDim+1;
   fRvec = new Double_t[fRNmax];   // Vector of random numbers
   if(fRvec==0)  Log() << kFATAL << "Cannot initialize buffer fRvec" << Endl;

   if(fDim>0){
      fAlpha = new Double_t[fDim];    // sum<1 for internal parametrization of the simplex
      if(fAlpha==0)  Log() << kFATAL << "Cannot initialize buffer fAlpha" << Endl;
   }
   fMCvect = new Double_t[fDim]; // vector generated in the MC run
   if(fMCvect==0)  Log() << kFATAL << "Cannot initialize buffer fMCvect" << Endl;

   //====== List of directions inhibited for division
   if(fInhiDiv == 0){
      fInhiDiv = new Int_t[fDim];
      for(i=0; i<fDim; i++) fInhiDiv[i]=0;
   }
   //====== Dynamic mask used in Explore for edge determination
   if(fMaskDiv == 0){
      fMaskDiv = new Int_t[fDim];
      for(i=0; i<fDim; i++) fMaskDiv[i]=1;
   }
   //====== List of predefined division values in all directions (initialized as empty)
   if(fXdivPRD == 0){
      fXdivPRD = new PDEFoamVect*[fDim];
      for(i=0; i<fDim; i++)  fXdivPRD[i]=0; // Artificially extended beyond fDim
   }
   //====== Initialize list of histograms
   fHistWt  = new TH1D("HistWt","Histogram of MC weight",100,0.0, 1.5*fMaxWtRej); // MC weight
   fHistEdg = new TObjArray(fDim);           // Initialize list of histograms
   TString hname;
   TString htitle;
   for(i=0;i<fDim;i++){
      hname=fName+TString("_HistEdge_");
      hname+=i;
      htitle=TString("Edge Histogram No. ");
      htitle+=i;
      (*fHistEdg)[i] = new TH1D(hname.Data(),htitle.Data(),fNBin,0.0, 1.0); // Initialize histogram for each edge
      ((TH1D*)(*fHistEdg)[i])->Sumw2();
   }
   //======  extra histograms for debug purposes
   fHistDbg = new TObjArray(fDim);         // Initialize list of histograms
   for(i=0;i<fDim;i++){
      hname=fName+TString("_HistDebug_");
      hname+=i;
      htitle=TString("Debug Histogram ");
      htitle+=i;
      (*fHistDbg)[i] = new TH1D(hname.Data(),htitle.Data(),fNBin,0.0, 1.0); // Initialize histogram for each edge
   }

   // ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| //
   //                     BUILD-UP of the FOAM                            //
   // ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| //
   //
   //        Define and explore root cell(s)
   InitCells(CreateCellElements);
   //        PrintCells(); Log()<<" ===== after InitCells ====="<<Endl;
   Grow();
   //        PrintCells(); Log()<<" ===== after Grow      ====="<<Endl;

   MakeActiveList(); // Final Preperations for the M.C. generation

   // Preperations for the M.C. generation
   fSumWt  = 0.0;               // M.C. generation sum of Wt
   fSumWt2 = 0.0;               // M.C. generation sum of Wt**2
   fSumOve = 0.0;               // M.C. generation sum of overweighted
   fNevGen = 0.0;               // M.C. generation sum of 1d0
   fWtMax  = gVlow;               // M.C. generation maximum wt
   fWtMin  = gHigh;               // M.C. generation minimum wt
   fMCresult=fCells[0]->GetIntg(); // M.C. Value of INTEGRAL,temporary assignment
   fMCresult=fCells[0]->GetIntg(); // M.C. Value of INTEGRAL,temporary assignment
   fMCerror =fCells[0]->GetIntg(); // M.C. Value of ERROR   ,temporary assignment
   fMCMonit = new PDEFoamMaxwt(5.0,1000);  // monitoring M.C. efficiency

   if(fChat==2) PrintCells();
   TH1::AddDirectory(addStatus);
} // Initialize

//_____________________________________________________________________________________________
void TMVA::PDEFoam::Initialize(TRandom3*PseRan, PDEFoamIntegrand *fun )
{
   // Basic initialization of FOAM invoked by the user. Mandatory!
   // ============================================================
   // This method starts the process of the cell build-up.
   // User must invoke Initialize with two arguments or Initialize without arguments.
   // This is done BEFORE generating first MC event and AFTER allocating FOAM object
   // and reseting (optionally) its internal parameters/switches.
   //
   // This method invokes several other methods:
   // ==========================================
   // InitCells initializes memory storage for cells and begins exploration process
   // from the root cell. The empty cells are allocated/filled using  CellFill.
   // The procedure Grow which loops over cells, picks up the cell with the biggest
   // ``driver integral'', see Comp. Phys. Commun. 152 152 (2003) 55 for explanations,
   // with the help of PeekMax procedure. The chosen cell is split using Divide.
   // Subsequently, the procedure Explore called by the Divide
   // (and by InitCells for the root cell) does the most important
   // job in the FOAM object build-up: it performs a small MC run for each
   // newly allocated daughter cell.
   // Explore calculates how profitable the future split of the cell will be
   // and defines the optimal cell division geometry with the help of Carver or Varedu
   // procedures, for maximum weight or variance optimization respectively.
   // All essential results of the exploration are written into
   // the explored cell object. At the very end of the foam build-up,
   // Finally, MakeActiveList is invoked to create a list of pointers to
   // all active cells, for the purpose of the quick access during the MC generation.
   // The procedure Explore employs MakeAlpha to generate random coordinates
   // inside a given cell with the uniform distribution.

   SetPseRan(PseRan);
   SetRho(fun);
   Initialize(kFALSE);
}

//_______________________________________________________________________________________
void TMVA::PDEFoam::InitCells(Bool_t CreateCellElements)
{
   // Internal subprogram used by Initialize.
   // It initializes "root part" of the FOAM of the tree of cells.

   Int_t i;

   fLastCe =-1;                             // Index of the last cell
   if(fCells!= 0) {
      for(i=0; i<fNCells; i++) delete fCells[i];
      delete [] fCells;
   }
   //
   fCells = new PDEFoamCell*[fNCells];
   for(i=0;i<fNCells;i++){
      fCells[i]= new PDEFoamCell(fDim); // Allocate BIG list of cells
      fCells[i]->SetSerial(i);
   }
   if(fCells==0) Log() << kFATAL << "Cannot initialize CELLS" << Endl;

   // create cell elemets
   if (CreateCellElements)
      ResetCellElements(true);

   /////////////////////////////////////////////////////////////////////////////
   //              Single Root Hypercube                                      //
   /////////////////////////////////////////////////////////////////////////////
   CellFill(1,   0);  //  0-th cell ACTIVE

   // Exploration of the root cell(s)
   for(Long_t iCell=0; iCell<=fLastCe; iCell++){
      Explore( fCells[iCell] );               // Exploration of root cell(s)
   }
}//InitCells

//_______________________________________________________________________________________
Int_t TMVA::PDEFoam::CellFill(Int_t Status, PDEFoamCell *parent)
{
   // Internal subprogram used by Initialize.
   // It initializes content of the newly allocated active cell.

   PDEFoamCell *cell;
   if (fLastCe==fNCells){
      Log() << kFATAL << "Too many cells" << Endl;
   }
   fLastCe++;   // 0-th cell is the first
   if (Status==1) fNoAct++;

   cell = fCells[fLastCe];

   cell->Fill(Status, parent, 0, 0);

   cell->SetBest( -1);         // pointer for planning division of the cell
   cell->SetXdiv(0.5);         // factor for division
   Double_t xInt2,xDri2;
   if(parent!=0){
      xInt2  = 0.5*parent->GetIntg();
      xDri2  = 0.5*parent->GetDriv();
      cell->SetIntg(xInt2);
      cell->SetDriv(xDri2);
   }else{
      cell->SetIntg(0.0);
      cell->SetDriv(0.0);
   }
   return fLastCe;
}

//_______________________________________________________________________________________________
void TMVA::PDEFoam::Explore(PDEFoamCell *cell)
{
   // Internal subprogram used by Initialize.
   // It explores newly defined cell with help of special short MC sampling.
   // As a result, estimates of kTRUE and drive volume is defined/determined
   // Average and dispersion of the weight distribution will is found along
   // each edge and the best edge (minimum dispersion, best maximum weight)
   // is memorized for future use.
   // The optimal division point for eventual future cell division is
   // determined/recorded. Recorded are also minimum and maximum weight etc.
   // The volume estimate in all (inactive) parent cells is updated.
   // Note that links to parents and initial volume = 1/2 parent has to be
   // already defined prior to calling this routine.
   //
   // This function is overridden from the original PDEFoam::Explore()
   // to provide an extra option:   Filling edge histograms directly from the 
   // input distributions, w/o MC sampling if fNSampl == 0
   // Warning:  This option is not tested jet!

   Double_t wt, dx, xBest, yBest;
   Double_t intOld, driOld;

   Long_t iev;
   Double_t nevMC;
   Int_t i, j, k;
   Int_t nProj, kBest;
   Double_t ceSum[5], xproj;

   Double_t event_density = 0;
   Double_t totevents     = 0;
   Double_t toteventsOld  = 0;

   PDEFoamVect  cellSize(fDim);
   PDEFoamVect  cellPosi(fDim);

   cell->GetHcub(cellPosi,cellSize);

   PDEFoamCell  *parent;

   Double_t *xRand = new Double_t[fDim];

   Double_t *volPart=0;

   cell->CalcVolume();
   dx = cell->GetVolume();
   intOld = cell->GetIntg(); //memorize old values,
   driOld = cell->GetDriv(); //will be needed for correcting parent cells
   if (CutNmin())
      toteventsOld = GetCellEvents(cell);

   /////////////////////////////////////////////////////
   //    Special Short MC sampling to probe cell      //
   /////////////////////////////////////////////////////
   ceSum[0]=0;
   ceSum[1]=0;
   ceSum[2]=0;
   ceSum[3]=gHigh;  //wtmin
   ceSum[4]=gVlow;  //wtmax
   //
   for (i=0;i<fDim;i++) ((TH1D *)(*fHistEdg)[i])->Reset(); // Reset histograms
   fHistWt->Reset();
   //

   Double_t nevEff=0.;

   // DD 10.Jan.2008
   // use new routine that fills edge histograms directly from the 
   // input distributions, w/o MC sampling
   if (fNSampl==0) {
      Double_t *cellPosiarr = new Double_t[Int_t(fDim)];
      Double_t *cellSizearr = new Double_t[Int_t(fDim)];
      for (Int_t idim=0; idim<fDim; idim++) {
         cellPosiarr[idim]=cellPosi[idim];
         cellSizearr[idim]=cellSize[idim];
      }
      // not jet implemented:
      // fRho->FillEdgeHist(fDim, fHistEdg, cellPosiarr, cellSizearr, ceSum, dx);
      delete[] cellPosiarr;
      delete[] cellSizearr;
   }   
   else {
      // ||||||||||||||||||||||||||BEGIN MC LOOP|||||||||||||||||||||||||||||
      for (iev=0;iev<fNSampl;iev++){
         MakeAlpha();               // generate uniformly vector inside hypercube
       
         if (fDim>0){
            for (j=0; j<fDim; j++)
               xRand[j]= cellPosi[j] +fAlpha[j]*(cellSize[j]);
         }
       
         wt         = dx*Eval(xRand, event_density);
	 totevents += dx*event_density;
       
         nProj = 0;
         if (fDim>0) {
            for (k=0; k<fDim; k++) {
               xproj =fAlpha[k];
               ((TH1D *)(*fHistEdg)[nProj])->Fill(xproj,wt);
               nProj++;
            }
         }
         //
         fNCalls++;
         ceSum[0] += wt;    // sum of weights
         ceSum[1] += wt*wt; // sum of weights squared
         ceSum[2]++;        // sum of 1
         if (ceSum[3]>wt) ceSum[3]=wt;  // minimum weight;
         if (ceSum[4]<wt) ceSum[4]=wt;  // maximum weight
         // test MC loop exit condition
         nevEff = ceSum[0]*ceSum[0]/ceSum[1];
         if ( nevEff >= fNBin*fEvPerBin) break;
      }   // ||||||||||||||||||||||||||END MC LOOP|||||||||||||||||||||||||||||
      totevents /= fNSampl;
   }

   // make shure that, if root cell is explored, more than zero
   // events were found.
   if (cell==fCells[0] && ceSum[0]<=0.0){
      if (ceSum[0]==0.0)
	 Log() << kFATAL << "No events were found during exploration of " 
	       << "root cell.  Please check PDEFoam parameters nSampl " 
	       << "and VolFrac." << Endl;
      else
	 Log() << kWARNING << "Negative number of events found during "
	       << "exploration of root cell" << Endl;
   }

   //------------------------------------------------------------------
   //---  predefine logics of searching for the best division edge ---
   for (k=0; k<fDim;k++){
      fMaskDiv[k] =1;                       // default is all
      if ( fInhiDiv[k]==1) fMaskDiv[k] =0; // inhibit some...
   }
   // Note that predefined division below overrule inhibition above
   kBest=-1;
   Double_t rmin,rmax,rdiv;
   if (fOptPRD) {          // quick check
      for (k=0; k<fDim; k++) {
         rmin= cellPosi[k];
         rmax= cellPosi[k] +cellSize[k];
         if ( fXdivPRD[k] != 0) {
            Int_t n= (fXdivPRD[k])->GetDim();
            for (j=0; j<n; j++) {
               rdiv=(*fXdivPRD[k])[j];
               // check predefined divisions is available in this cell
               if ( (rmin +1e-99 <rdiv) && (rdiv< rmax -1e-99)) {
                  kBest=k;
                  xBest= (rdiv-cellPosi[k])/cellSize[k] ;
                  goto ee05;
               }
            }
         }
      }//k
   }
 ee05:
   //------------------------------------------------------------------
   fNEffev += (Long_t)nevEff;
   nevMC          = ceSum[2];
   Double_t intTrue = ceSum[0]/(nevMC+0.000001);
   Double_t intDriv=0.;
   Double_t intPrim=0.;
   
   switch(fOptDrive){
   case 1:                       // VARIANCE REDUCTION
      if (kBest == -1) Varedu(ceSum,kBest,xBest,yBest); // determine the best edge,
      if (CutRMSmin())
         intDriv =sqrt( ceSum[1]/nevMC -intTrue*intTrue ); // Older ansatz, numerically not bad
      else
         intDriv =sqrt(ceSum[1]/nevMC) -intTrue; // Foam build-up, sqrt(<w**2>) -<w>
      intPrim =sqrt(ceSum[1]/nevMC);          // MC gen. sqrt(<w**2>) =sqrt(<w>**2 +sigma**2)
      break;
   case 2:                       // WTMAX  REDUCTION
      if (kBest == -1) Carver(kBest,xBest,yBest);  // determine the best edge
      intDriv =ceSum[4] -intTrue; // Foam build-up, wtmax-<w>
      intPrim =ceSum[4];          // MC generation, wtmax!
      break;
   default:
      Log() << kFATAL << "Wrong fOptDrive = " << Endl;
   }//switch
   //=================================================================================
   //hist_Neff_distrib.Fill( fLastCe/2.0+0.01, nevEff+0.01);  //
   //hist_kBest_distrib.Fill( kBest+0.50, 1.0 ); //  debug
   //hist_xBest_distrib.Fill( xBest+0.01, 1.0 ); //  debug
   //=================================================================================
   cell->SetBest(kBest);
   cell->SetXdiv(xBest);
   cell->SetIntg(intTrue);
   cell->SetDriv(intDriv);
   cell->SetPrim(intPrim);
   if (CutNmin())
      SetCellElement(cell, 0, totevents);
   
   // correct/update integrals in all parent cells to the top of the tree
   Double_t  parIntg, parDriv;
   for (parent = cell->GetPare(); parent!=0; parent = parent->GetPare()){
      parIntg = parent->GetIntg();
      parDriv = parent->GetDriv();
      parent->SetIntg( parIntg   +intTrue -intOld );
      parent->SetDriv( parDriv   +intDriv -driOld );
      if (CutNmin())
	 SetCellElement( parent, 0, GetCellEvents(parent) + totevents - toteventsOld);
   }
   delete [] volPart;
   delete [] xRand;

}

//______________________________________________________________________________________
void TMVA::PDEFoam::Varedu(Double_t ceSum[5], Int_t &kBest, Double_t &xBest, Double_t &yBest)
{
   // Internal subrogram used by Initialize.
   // In determines the best edge candidate and the position of the cell division plane
   // in case of the variance reduction for future cell division,
   // using results of the MC exploration run stored in fHistEdg

   Double_t nent   = ceSum[2];
   Double_t swAll  = ceSum[0];
   Double_t sswAll = ceSum[1];
   Double_t ssw    = sqrt(sswAll)/sqrt(nent);
   //
   Double_t swIn,swOut,sswIn,sswOut,xLo,xUp;
   kBest =-1;
   xBest =0.5;
   yBest =1.0;
   Double_t maxGain=0.0;
   // Now go over all projections kProj
   for(Int_t kProj=0; kProj<fDim; kProj++) {
      if( fMaskDiv[kProj]) {
         // initialize search over bins
         Double_t sigmIn =0.0; Double_t sigmOut =0.0;
         Double_t sswtBest = gHigh;
         Double_t gain =0.0;
         Double_t xMin=0.0; Double_t xMax=0.0;
         // Double loop over all pairs jLo<jUp
         for(Int_t jLo=1; jLo<=fNBin; jLo++) {
            Double_t aswIn=0;  Double_t asswIn=0;
            for(Int_t jUp=jLo; jUp<=fNBin;jUp++) {
	      aswIn  +=     ((TH1D *)(*fHistEdg)[kProj])->GetBinContent(jUp);
	      asswIn += Sqr(((TH1D *)(*fHistEdg)[kProj])->GetBinError(  jUp));
              xLo=(jLo-1.0)/fNBin;
               xUp=(jUp*1.0)/fNBin;
               swIn  =        aswIn/nent;
               swOut = (swAll-aswIn)/nent;
               sswIn = sqrt(asswIn)       /sqrt(nent*(xUp-xLo))     *(xUp-xLo);
               sswOut= sqrt(sswAll-asswIn)/sqrt(nent*(1.0-xUp+xLo)) *(1.0-xUp+xLo);
               if( (sswIn+sswOut) < sswtBest) {
                  sswtBest = sswIn+sswOut;
                  gain     = ssw-sswtBest;
                  sigmIn   = sswIn -swIn;  // Debug
                  sigmOut  = sswOut-swOut; // Debug
                  xMin    = xLo;
                  xMax    = xUp;
               }
            }//jUp
         }//jLo
         Int_t iLo = (Int_t) (fNBin*xMin);
         Int_t iUp = (Int_t) (fNBin*xMax);
         //----------DEBUG printout
         //Log()<<"@@@@@  xMin xMax = "<<xMin   <<" "<<xMax<<"  iLo= "<<iLo<<"  iUp= "<<iUp;
         //Log()<<"  sswtBest/ssw= "<<sswtBest/ssw<<"  Gain/ssw= "<< Gain/ssw<<Endl;
         //----------DEBUG auxilary Plot
	 //         for(Int_t iBin=1;iBin<=fNBin;iBin++) {
	 //            if( ((iBin-0.5)/fNBin > xMin) && ((iBin-0.5)/fNBin < xMax) ){
	 //               ((TH1D *)(*fHistDbg)[kProj])->SetBinContent(iBin,sigmIn/(xMax-xMin));
	 //            } else {
	 //               ((TH1D *)(*fHistDbg)[kProj])->SetBinContent(iBin,sigmOut/(1-xMax+xMin));
	 //            }
	 //         }
         if(gain>=maxGain) {
            maxGain=gain;
            kBest=kProj; // <--- !!!!! The best edge
            xBest=xMin;
            yBest=xMax;
            if(iLo == 0)     xBest=yBest; // The best division point
            if(iUp == fNBin) yBest=xBest; // this is not really used
         }
      }
   } //kProj
   //----------DEBUG printout
   //Log()<<"@@@@@@@>>>>> kBest= "<<kBest<<"  maxGain/ssw= "<< maxGain/ssw<<Endl;
   if( (kBest >= fDim) || (kBest<0) ) Log() << kFATAL << "Something wrong with kBest" << Endl;
}          //PDEFoam::Varedu

//________________________________________________________________________________________
void TMVA::PDEFoam::Carver(Int_t &kBest, Double_t &xBest, Double_t &yBest)
{
   // Internal subrogram used by Initialize.
   // Determines the best edge-candidate and the position of the division plane
   // for the future cell division, in the case of the optimization of the maximum weight.
   // It exploits results of the cell MC exploration run stored in fHistEdg.

   Int_t    kProj,iBin;
   Double_t carve,carvTot,carvMax,carvOne,binMax,binTot,primTot,primMax;
   Int_t    jLow,jUp,iLow,iUp;
   Double_t theBin;
   Int_t    jDivi; // TEST
   Int_t j;

   Double_t *bins  = new Double_t[fNBin];      // bins of histogram for single  PROJECTION
   if(bins==0)    Log() << kFATAL << "Cannot initialize buffer Bins " << Endl;

   kBest =-1;
   xBest =0.5;
   yBest =1.0;
   carvMax = gVlow;
   primMax = gVlow;
   for(kProj=0; kProj<fDim; kProj++)
      if( fMaskDiv[kProj] ){
         //if( kProj==1 ){
         //Log()<<"==================== Carver histogram: kProj ="<<kProj<<"==================="<<Endl;
         //((TH1D *)(*fHistEdg)[kProj])->Print("all");
         binMax = gVlow;
         for(iBin=0; iBin<fNBin;iBin++){
            bins[iBin]= ((TH1D *)(*fHistEdg)[kProj])->GetBinContent(iBin+1);
            binMax = TMath::Max( binMax, bins[iBin]);       // Maximum content/bin
         }
         if(binMax < 0 ) {       //case of empty cell
            delete [] bins;
            return;
         }
         carvTot = 0.0;
         binTot  = 0.0;
         for(iBin=0;iBin<fNBin;iBin++){
            carvTot = carvTot + (binMax-bins[iBin]);     // Total Carve (more stable)
            binTot  +=bins[iBin];
         }
         primTot = binMax*fNBin;
         //Log() <<"Carver:  CarvTot "<<CarvTot<< "    primTot "<<primTot<<Endl;
         jLow =0;
         jUp  =fNBin-1;
         carvOne = gVlow;
         Double_t yLevel = gVlow;
         for(iBin=0; iBin<fNBin;iBin++) {
            theBin = bins[iBin];
            //-----  walk to the left and find first bin > theBin
            iLow = iBin;
            for(j=iBin; j>-1; j-- ) {
               if(theBin< bins[j]) break;
               iLow = j;
            }
            //iLow = iBin;
            //if(iLow>0)     while( (theBin >= bins[iLow-1])&&(iLow >0) ){iLow--;} // horror!!!
            //------ walk to the right and find first bin > theBin
            iUp  = iBin;
            for(j=iBin; j<fNBin; j++) {
               if(theBin< bins[j]) break;
               iUp = j;
            }
            //iUp  = iBin;
            //if(iUp<fNBin-1) while( (theBin >= bins[iUp+1])&&( iUp<fNBin-1 ) ){iUp++;} // horror!!!
            //
            carve = (iUp-iLow+1)*(binMax-theBin);
            if( carve > carvOne) {
               carvOne = carve;
               jLow = iLow;
               jUp  = iUp;
               yLevel = theBin;
            }
         }//iBin
         if( carvTot > carvMax) {
            carvMax   = carvTot;
            primMax   = primTot;
            //Log() <<"Carver:   primMax "<<primMax<<Endl;
            kBest = kProj;    // Best edge
            xBest = ((Double_t)(jLow))/fNBin;
            yBest = ((Double_t)(jUp+1))/fNBin;
            if(jLow == 0 )       xBest = yBest;
            if(jUp  == fNBin-1) yBest = xBest;
            // division ratio in units of 1/fNBin, testing
            jDivi = jLow;
            if(jLow == 0 )     jDivi=jUp+1;
         }
         //======  extra histograms for debug purposes
         //Log()<<"kProj= "<<kProj<<" jLow= "<<jLow<<" jUp= "<<jUp<<Endl;
         for(iBin=0;    iBin<fNBin;  iBin++)
            ((TH1D *)(*fHistDbg)[kProj])->SetBinContent(iBin+1,binMax);
         for(iBin=jLow; iBin<jUp+1;   iBin++)
            ((TH1D *)(*fHistDbg)[kProj])->SetBinContent(iBin+1,yLevel);
      }//kProj
   if( (kBest >= fDim) || (kBest<0) ) Log() << kFATAL << "Something wrong with kBest" << Endl;
   delete [] bins;
}          //PDEFoam::Carver

//______________________________________________________________________________________________
void TMVA::PDEFoam::MakeAlpha()
{
   // Internal subrogram used by Initialize.
   // Provides random vector Alpha  0< Alpha(i) < 1
   Int_t k;
   if(fDim<1) return;

   // simply generate and load kDim uniform random numbers
   fPseRan->RndmArray(fDim,fRvec);   // kDim random numbers needed
   for(k=0; k<fDim; k++) fAlpha[k] = fRvec[k];
} //MakeAlpha

//_____________________________________________________________________________________________
Long_t TMVA::PDEFoam::PeekMax()
{
   // Internal subprogram used by Initialize.
   // It finds cell with maximal driver integral for the purpose of the division.
   // This function is overridden by the PDEFoam Class to apply cuts
   // on Nmin and RMSmin during cell buildup.

   Long_t iCell = -1;

   Long_t  i;
   Double_t  drivMax, driv;
   Bool_t bCutNmin = kTRUE;
   Bool_t bCutRMS  = kTRUE;
   //   drivMax = gVlow;
   drivMax = 0;  // only split cells if gain>0 (this also avoids splitting at cell boundary)
   for(i=0; i<=fLastCe; i++) {//without root
      if( fCells[i]->GetStat() == 1 ) {
	 driv =  TMath::Abs( fCells[i]->GetDriv());
	 // apply RMS-cut for all options
	 if (CutRMSmin()){  
	    // calc error on rms, but how?
	    bCutRMS = driv > GetRMSmin() /*&& driv > driv_err*/;
	    Log() << kINFO << "rms[cell "<<i<<"]=" << driv << Endl;
	 }

	 // apply Nmin-cut
	 if (CutNmin())
	    bCutNmin = GetCellEvents(fCells[i]) > GetNmin();

	 // choose cell
	 if(driv > drivMax && bCutNmin && bCutRMS) {
	    drivMax = driv;
	    iCell = i;
	 }
      }
   }
   //   cout << "drivMax: " << drivMax << " iCell: " << iCell << " xdiv: " 
   //	<< fCells[iCell]->GetXdiv() << " GetDriv: " << fCells[iCell]->GetDriv() << endl;

   if (iCell == -1){
     if (!bCutNmin)
	 Log() << kVERBOSE << "Warning: No cell with more than " << GetNmin() << " events found!" << Endl;
      else if (!bCutRMS)
	 Log() << kVERBOSE << "Warning: No cell with RMS/mean > " << GetRMSmin() << " found!" << Endl;
      else
	 Log() << kWARNING << "Warning: PDEFoam::PeekMax: no more candidate cells (drivMax>0) found for further splitting." << Endl;
   }

   return(iCell);
}

//_____________________________________________________________________________________________
Int_t TMVA::PDEFoam::Divide(PDEFoamCell *cell)
{
   // Internal subrogram used by Initialize.
   // It divides cell iCell into two daughter cells.
   // The iCell is retained and tagged as inactive, daughter cells are appended
   // at the end of the buffer.
   // New vertex is added to list of vertices.
   // List of active cells is updated, iCell removed, two daughters added
   // and their properties set with help of MC sampling (PDEFoam_Explore)
   // Returns Code RC=-1 of buffer limit is reached,  fLastCe=fnBuf.

   Double_t xdiv;
   Int_t   kBest;

   if(fLastCe+1 >= fNCells) Log() << kFATAL << "Buffer limit is reached, fLastCe=fnBuf" << Endl;

   cell->SetStat(0); // reset cell as inactive
   fNoAct--;

   xdiv  = cell->GetXdiv();
   kBest = cell->GetBest();
   if( kBest<0 || kBest>=fDim ) Log() << kFATAL << "Wrong kBest" << Endl;

   //////////////////////////////////////////////////////////////////
   //           define two daughter cells (active)                 //
   //////////////////////////////////////////////////////////////////

   Int_t d1 = CellFill(1,   cell);
   Int_t d2 = CellFill(1,   cell);
   cell->SetDau0((fCells[d1]));
   cell->SetDau1((fCells[d2]));
   Explore( (fCells[d1]) );
   Explore( (fCells[d2]) );
   return 1;
} // PDEFoam_Divide

//_________________________________________________________________________________________
void TMVA::PDEFoam::MakeActiveList()
{
   // Internal subrogram used by Initialize.
   // It finds out number of active cells fNoAct,
   // creates list of active cell fCellsAct and primary cumulative fPrimAcu.
   // They are used during the MC generation to choose randomly an active cell.

   Long_t n, iCell;
   Double_t sum;
   // flush previous result
   if(fPrimAcu  != 0) delete [] fPrimAcu;
   if(fCellsAct != 0) delete fCellsAct;

   // Allocate tables of active cells
   fCellsAct = new TRefArray();

   // Count Active cells and find total Primary
   // Fill-in tables of active cells

   fPrime = 0.0; n = 0;
   for(iCell=0; iCell<=fLastCe; iCell++) { 
      if (fCells[iCell]->GetStat()==1) {
         fPrime += fCells[iCell]->GetPrim();
         fCellsAct->Add(fCells[iCell]);
         n++;
      }
   }

   if(fNoAct != n)  Log() << kFATAL << "Wrong fNoAct              " << Endl;
   if(fPrime == 0.) Log() << kFATAL << "Integrand function is zero" << Endl;

   fPrimAcu  = new  Double_t[fNoAct]; // cumulative primary for MC generation
   if( fCellsAct==0 || fPrimAcu==0 ) Log() << kFATAL << "Cant allocate fCellsAct or fPrimAcu" << Endl;

   sum =0.0;
   for(iCell=0; iCell<fNoAct; iCell++) {
      sum = sum + ( (PDEFoamCell *) (fCellsAct->At(iCell)) )->GetPrim()/fPrime;
      fPrimAcu[iCell]=sum;
   }

} //MakeActiveList

//___________________________________________________________________________________________
void TMVA::PDEFoam::GenerCel2(PDEFoamCell *&pCell)
{
   // Internal subprogram.
   // Return randomly chosen active cell with probability equal to its
   // contribution into total driver integral using interpolation search.

   Long_t  lo, hi, hit;
   Double_t fhit, flo, fhi;
   Double_t random;

   random=fPseRan->Rndm();
   lo  = 0;              hi =fNoAct-1;
   flo = fPrimAcu[lo];  fhi=fPrimAcu[hi];
   while(lo+1<hi) {
      hit = lo + (Int_t)( (hi-lo)*(random-flo)/(fhi-flo)+0.5);
      if (hit<=lo)
         hit = lo+1;
      else if(hit>=hi)
         hit = hi-1;
      fhit=fPrimAcu[hit];
      if (fhit>random) {
         hi = hit;
         fhi = fhit;
      } else {
         lo = hit;
         flo = fhit;
      }
   }
   if (fPrimAcu[lo]>random)
      pCell = (PDEFoamCell *) fCellsAct->At(lo);
   else
      pCell = (PDEFoamCell *) fCellsAct->At(hi);
}       // PDEFoam::GenerCel2

//__________________________________________________________________________________________
Double_t TMVA::PDEFoam::Eval(Double_t *xRand, Double_t &event_density)
{
   // Internal subprogram.
   // Evaluates distribution to be generated.

   Double_t result = 0;

   if(!fRho) {   //interactive mode
      Log() << kFATAL << "No binary tree given!" << Endl;
   } else {       //compiled mode
      result=fRho->Density(fDim,xRand,event_density);
   }

   return result;
}

//_____________________________________________________________________________________________
void TMVA::PDEFoam::Grow()
{
   // Internal subrogram used by Initialize.
   // It grow new cells by the binary division process.
   // This function is overridden by the PDEFoam class to stop the foam buildup process
   // if one of the cut conditions stop the cell split.

   fTimer->Init(fNCells);

   Long_t iCell;
   PDEFoamCell* newCell;

   while ( (fLastCe+2) < fNCells ) {  // this condition also checked inside Divide
      iCell   = PeekMax();            // peek up cell with maximum driver integral
      if ( (iCell<0) || (iCell>fLastCe) ) {
	 Log() << kVERBOSE << "Break: "<< fLastCe+1 << " cells created" << Endl;
	 // remove remaining empty cells
	 for (Long_t jCell=fLastCe+1; jCell<fNCells; jCell++)
	    delete fCells[jCell];
	 fNCells = fLastCe+1;
	 break;
      }
      newCell = fCells[iCell];

      OutputGrow();

      if ( Divide( newCell )==0) break;  // and divide it into two
   }
   OutputGrow( kTRUE );
   CheckAll(1);   // set arg=1 for more info
      
   Log() << kINFO << GetNActiveCells() << " active cells created" << Endl;
}// Grow

//___________________________________________________________________________________________
void TMVA::PDEFoam::MakeEvent(void)
{
   // User subprogram.
   // It generates randomly point/vector according to user-defined distribution.
   // Prior initialization with help of Initialize() is mandatory.
   // Generated MC point/vector is available using GetMCvect and the MC weight with GetMCwt.
   // MC point is generated with wt=1 or with variable weight, see OptRej switch.

   Int_t      j;
   Double_t   wt,dx,mcwt;
   PDEFoamCell *rCell;
   //
   //********************** MC LOOP STARS HERE **********************
 ee0:
   GenerCel2(rCell);   // choose randomly one cell

   MakeAlpha();

   PDEFoamVect  cellPosi(fDim); PDEFoamVect  cellSize(fDim);
   rCell->GetHcub(cellPosi,cellSize);
   for(j=0; j<fDim; j++)
      fMCvect[j]= cellPosi[j] +fAlpha[j]*cellSize[j];
   dx = rCell->GetVolume();      // Cartesian volume of the Cell
   //  weight average normalized to PRIMARY integral over the cell

   wt=dx*Eval(fMCvect);

   mcwt = wt / rCell->GetPrim();  // PRIMARY controls normalization
   fNCalls++;
   fMCwt   =  mcwt;
   // accumulation of statistics for the main MC weight
   fSumWt  += mcwt;           // sum of Wt
   fSumWt2 += mcwt*mcwt;      // sum of Wt**2
   fNevGen++;                 // sum of 1d0
   fWtMax  =  TMath::Max(fWtMax, mcwt);   // maximum wt
   fWtMin  =  TMath::Min(fWtMin, mcwt);   // minimum wt
   fMCMonit->Fill(mcwt);
   fHistWt->Fill(mcwt,1.0);          // histogram
   //*******  Optional rejection ******
   if(fOptRej == 1) {
      Double_t random;
      random=fPseRan->Rndm();
      if( fMaxWtRej*random > fMCwt) goto ee0;  // Wt=1 events, internal rejection
      if( fMCwt<fMaxWtRej ) {
         fMCwt = 1.0;                  // normal Wt=1 event
      } else {
         fMCwt = fMCwt/fMaxWtRej;    // weight for overweighted events! kept for debug
         fSumOve += fMCwt-fMaxWtRej; // contribution of overweighted
      }
   }
   //********************** MC LOOP ENDS HERE **********************
} // MakeEvent

//_________________________________________________________________________________
void TMVA::PDEFoam::GetMCvect(Double_t *MCvect)
{
   // User may get generated MC point/vector with help of this method

   for ( Int_t k=0 ; k<fDim ; k++) *(MCvect +k) = fMCvect[k];
}//GetMCvect

//___________________________________________________________________________________
Double_t TMVA::PDEFoam::GetMCwt(void)
{
   // User may get weight MC weight using this method

   return(fMCwt);
}
//___________________________________________________________________________________
void TMVA::PDEFoam::GetMCwt(Double_t &mcwt)
{
   // User may get weight MC weight using this method

   mcwt=fMCwt;
}

//___________________________________________________________________________________
Double_t TMVA::PDEFoam::MCgenerate(Double_t *MCvect)
{
   // User subprogram which generates MC event and returns MC weight

   MakeEvent();
   GetMCvect(MCvect);
   return(fMCwt);
}//MCgenerate

//___________________________________________________________________________________
void TMVA::PDEFoam::GetIntegMC(Double_t &mcResult, Double_t &mcError)
{
   // User subprogram.
   // It provides the value of the integral calculated from the averages of the MC run
   // May be called after (or during) the MC run.

   Double_t mCerelat;
   mcResult = 0.0;
   mCerelat = 1.0;
   if (fNevGen>0) {
      mcResult = fPrime*fSumWt/fNevGen;
      mCerelat = sqrt( fSumWt2/(fSumWt*fSumWt) - 1/fNevGen);
   }
   mcError = mcResult *mCerelat;
}//GetIntegMC

//____________________________________________________________________________________
void  TMVA::PDEFoam::GetIntNorm(Double_t& IntNorm, Double_t& Errel )
{
   // User subprogram.
   // It returns NORMALIZATION integral to be combined with the average weights
   // and content of the histograms in order to get proper absolute normalization
   // of the integrand and distributions.
   // It can be called after initialization, before or during the MC run.

   if(fOptRej == 1) {    // Wt=1 events, internal rejection
      Double_t intMC,errMC;
      GetIntegMC(intMC,errMC);
      IntNorm = intMC;
      Errel   = errMC;
   } else {                // Wted events, NO internal rejection
      IntNorm = fPrime;
      Errel   = 0;
   }
}//GetIntNorm

//______________________________________________________________________________________
void  TMVA::PDEFoam::GetWtParams(Double_t eps, Double_t &aveWt, Double_t &wtMax, Double_t &sigma)
{
   // May be called optionally after the MC run.
   // Returns various parameters of the MC weight for efficiency evaluation

   Double_t mCeff, wtLim;
   fMCMonit->GetMCeff(eps, mCeff, wtLim);
   wtMax = wtLim;
   aveWt = fSumWt/fNevGen;
   sigma = sqrt( fSumWt2/fNevGen -aveWt*aveWt );
}//GetmCeff

//_______________________________________________________________________________________
void TMVA::PDEFoam::Finalize(Double_t& IntNorm, Double_t& Errel)
{
   // May be called optionally by the user after the MC run.
   // It provides normalization and also prints some information/statistics on the MC run.

   GetIntNorm(IntNorm,Errel);
   Double_t mcResult,mcError;
   GetIntegMC(mcResult,mcError);
//    Double_t mCerelat= mcError/mcResult;

//    if(fChat>0) {
//       Double_t eps = 0.0005;
//       Double_t mCeff, mcEf2, wtMax, aveWt, sigma;
//       GetWtParams(eps, aveWt, wtMax, sigma);
//       mCeff=0;
//       if(wtMax>0.0) mCeff=aveWt/wtMax;
//       mcEf2 = sigma/aveWt;
//       Double_t driver = fCells[0]->GetDriv();

//       BXOPE;
//       BXTXT("****************************************");
//       BXTXT("******  TMVA::PDEFoam::Finalize    ******");
//       BXTXT("****************************************");
//       BX1I("    NevGen",fNevGen, "Number of generated events in the MC generation   ");
//       BX1I("    nCalls",fNCalls, "Total number of function calls                    ");
//       BXTXT("----------------------------------------");
//       BX1F("     AveWt",aveWt,    "Average MC weight                      ");
//       BX1F("     WtMin",fWtMin,  "Minimum MC weight (absolute)           ");
//       BX1F("     WtMax",fWtMax,  "Maximum MC weight (absolute)           ");
//       BXTXT("----------------------------------------");
//       BX1F("    XPrime",fPrime,  "Primary total integral, R_prime        ");
//       BX1F("    XDiver",driver,   "Driver  total integral, R_loss         ");
//       BXTXT("----------------------------------------");
//       BX2F("    IntMC", mcResult,  mcError,      "Result of the MC Integral");
//       BX1F(" mCerelat", mCerelat,  "Relative error of the MC integral      ");
//       BX1F(" <w>/WtMax",mCeff,     "MC efficiency, acceptance rate");
//       BX1F(" Sigma/<w>",mcEf2,     "MC efficiency, variance/ave_wt");
//       BX1F("     WtMax",wtMax,     "WtMax(esp= 0.0005)            ");
//       BX1F("     Sigma",sigma,     "variance of MC weight         ");
//       if(fOptRej==1) {
//          Double_t avOve=fSumOve/fSumWt;
//          BX1F("<OveW>/<W>",avOve,     "Contrib. of events wt>MaxWtRej");
//       }
//       BXCLO;
//    }
}  // Finalize

//__________________________________________________________________________________________
void TMVA::PDEFoam::ResetPseRan(TRandom3*PseRan)
{
   // User may optionally reset random number generator using this method
   // Usually it is done when FOAM object is restored from the disk.
   // IMPORTANT: this method deletes existing  random number generator registered in the FOAM object.
   // In particular such an object is created by the streamer during the disk-read operation.

   if(fPseRan) {
      Info("ResetPseRan", "Resetting random number generator  \n");
      delete fPseRan;
   }
   SetPseRan(PseRan);
}

//__________________________________________________________________________________________
void TMVA::PDEFoam::SetRho(PDEFoamIntegrand *fun)
{
   // User may use this method to set (register) random number generator used by
   // the given instance of the FOAM event generator. Note that single r.n. generator
   // may serve several FOAM objects.

   if (fun)
      fRho=fun;
   else
      Log() << kFATAL << "Bad function" << Endl;
}

//__________________________________________________________________________________________
void TMVA::PDEFoam::ResetRho(PDEFoamIntegrand *fun)
{
   // User may optionally reset the distribution using this method
   // Usually it is done when FOAM object is restored from the disk.
   // IMPORTANT: this method deletes existing  distribution object registered in the FOAM object.
   // In particular such an object is created by the streamer diring the disk-read operation.
   // This method is used only in very special cases, because the distribution in most cases
   // should be "owned" by the FOAM object and should not be replaced by another one after initialization.

   if(fRho) {
      Info("ResetRho", "!!! Resetting distribution function  !!!\n");
      delete fRho;
   }
   SetRho(fun);
}

//__________________________________________________________________________________________
void TMVA::PDEFoam::SetRhoInt(void *fun)
{
   // User may use this to set pointer to the global function (not descending
   // from PDEFoamIntegrand) serving as a distribution for FOAM.
   // It is useful for simple interactive applications.
   // Note that persistency for FOAM object will not work in the case of such
   // a distribution.

   const Char_t *namefcn = G__p2f2funcname(fun); //name of integrand function
   if(namefcn) {
      fMethodCall=new TMethodCall();
      fMethodCall->InitWithPrototype(namefcn, "Int_t, Double_t *");
   }
   fRho=0;
}

//_____________________________________________________________________________________
void  TMVA::PDEFoam::SetInhiDiv(Int_t iDim, Int_t InhiDiv)
{
   // This can be called before Initialize, after setting kDim
   // It defines which variables are excluded in the process of the cell division.
   // For example 'FoamX->SetInhiDiv(1, 1);' inhibits division of y-variable.

   if(fDim==0) Log() << kFATAL << "SetInhiDiv: fDim=0" << Endl;
   if(fInhiDiv == 0) {
      fInhiDiv = new Int_t[ fDim ];
      for(Int_t i=0; i<fDim; i++) fInhiDiv[i]=0;
   }
   //
   if( ( 0<=iDim) && (iDim<fDim)) {
      fInhiDiv[iDim] = InhiDiv;
   } else
      Log() << kFATAL << "Wrong iDim" << Endl;
}//SetInhiDiv

//______________________________________________________________________________________
void  TMVA::PDEFoam::SetXdivPRD(Int_t iDim, Int_t len, Double_t xDiv[])
{
   // This should be called before Initialize, after setting  kDim
   // It predefines values of the cell division for certain variable iDim.

   Int_t i;

   if(fDim<=0)    Log() << kFATAL << "fDim=0" << Endl;
   if(   len<1 )  Log() << kFATAL << "len<1"  << Endl;
   // allocate list of pointers, if it was not done before
   if(fXdivPRD == 0) {
      fXdivPRD = new PDEFoamVect*[fDim];
      for(i=0; i<fDim; i++)  fXdivPRD[i]=0;
   }
   // set division list for direction iDim in H-cubic space!!!
   if( ( 0<=iDim) && (iDim<fDim)) {
      fOptPRD =1;      // !!!!
      if( fXdivPRD[iDim] != 0)
         Log() << kFATAL << "Second allocation of XdivPRD not allowed" << Endl;
      fXdivPRD[iDim] = new PDEFoamVect(len); // allocate list of division points
      for(i=0; i<len; i++) {
         (*fXdivPRD[iDim])[i]=xDiv[i]; // set list of division points
      }
   } else {
      Log() << kFATAL << "Wrong iDim" << Endl;
   }
   // Priting predefined division points
   Log()<<" SetXdivPRD, idim= "<<iDim<<"  len= "<<len<<"   "<<Endl;
   for(i=0; i<len; i++) {
      Log()<< (*fXdivPRD[iDim])[i] <<"  ";
   }
   Log()<<Endl;
   for(i=0; i<len; i++)  Log()<< xDiv[i] <<"   ";
   Log()<<Endl;
   //
}//SetXdivPRD

//_______________________________________________________________________________________
void TMVA::PDEFoam::CheckAll(Int_t level)
{
   //  User utility, miscellaneous and debug.
   //  Checks all pointers in the tree of cells. This is useful autodiagnostic.
   //  level=0, no printout, failures causes STOP
   //  level=1, printout, failures lead to WARNINGS only

   Int_t errors, warnings;
   PDEFoamCell *cell;
   Long_t iCell;

   errors = 0; warnings = 0;
   if (level==1) Log() <<  "Performing consistency checks for created foam" << Endl;
   for(iCell=1; iCell<=fLastCe; iCell++) {
      cell = fCells[iCell];
      //  checking general rules
      if( ((cell->GetDau0()==0) && (cell->GetDau1()!=0) ) ||
          ((cell->GetDau1()==0) && (cell->GetDau0()!=0) ) ) {
         errors++;
         if (level==1) Log() << kFATAL << "ERROR: Cell's no %d has only one daughter " << iCell << Endl;
      }
      if( (cell->GetDau0()==0) && (cell->GetDau1()==0) && (cell->GetStat()==0) ) {
         errors++;
         if (level==1) Log() << kFATAL << "ERROR: Cell's no %d  has no daughter and is inactive " << iCell << Endl;
      }
      if( (cell->GetDau0()!=0) && (cell->GetDau1()!=0) && (cell->GetStat()==1) ) {
         errors++;
         if (level==1) Log() << kFATAL << "ERROR: Cell's no %d has two daughters and is active " << iCell << Endl;
      }

      // checking parents
      if( (cell->GetPare())!=fCells[0] ) { // not child of the root
         if ( (cell != cell->GetPare()->GetDau0()) && (cell != cell->GetPare()->GetDau1()) ) {
            errors++;
            if (level==1) Log() << kFATAL << "ERROR: Cell's no %d parent not pointing to this cell " << iCell << Endl;
         }
      }

      // checking daughters
      if(cell->GetDau0()!=0) {
         if(cell != (cell->GetDau0())->GetPare()) {
            errors++;
            if (level==1)  Log() << kFATAL << "ERROR: Cell's no %d daughter 0 not pointing to this cell " << iCell << Endl;
         }
      }
      if(cell->GetDau1()!=0) {
         if(cell != (cell->GetDau1())->GetPare()) {
            errors++;
            if (level==1) Log() << kFATAL << "ERROR: Cell's no %d daughter 1 not pointing to this cell " << iCell << Endl;
         }
      }
     if(cell->GetVolume()<1E-50) {
         errors++;
         if(level==1) Log() << kFATAL << "ERROR: Cell no. %d has Volume of <1E-50" << iCell << Endl;
     }
    }// loop after cells;

   // Check for cells with Volume=0
   for(iCell=0; iCell<=fLastCe; iCell++) {
      cell = fCells[iCell];
      if( (cell->GetStat()==1) && (cell->GetVolume()<1E-11) ) {
         errors++;
         if(level==1) Log() << kFATAL << "ERROR: Cell no. " << iCell << " is active but Volume is 0 " <<  Endl;
      }
   }
   // summary
   if(level==1){
     Log() << kINFO << "Check has found " << errors << " errors and " << warnings << " warnings." << Endl;
   }
   if(errors>0){
      Info("CheckAll","Check - found total %d  errors \n",errors);
   }
} // Check

//________________________________________________________________________________________
void TMVA::PDEFoam::PrintCells(void)
{
   // Prints geometry of ALL cells of the FOAM

   Long_t iCell;

   for(iCell=0; iCell<=fLastCe; iCell++) {
      Log()<<"Cell["<<iCell<<"]={ ";
      Log()<<"  "<< fCells[iCell]<<"  ";  // extra DEBUG
      Log()<<Endl;
      fCells[iCell]->Print("1");
      Log()<<"}"<<Endl;
   }
}

//________________________________________________________________________________________
void TMVA::PDEFoam::LinkCells()
{
   // Void function for backward compatibility

   Info("LinkCells", "VOID function for backward compatibility \n");
   return;
}

//_______________________________________________________________________________________________
Double_t TMVA::PDEFoam::GetSumCellElements(UInt_t i)
{
   // returns the sum of all cell elements with index i of all active cells
   Double_t intg = 0;
   for (Long_t iCell=0; iCell<=fLastCe; iCell++) {
      if (fCells[iCell]->GetStat())
         intg += GetCellElement(fCells[iCell], i);
   }
   return intg;
}

//_______________________________________________________________________________________________
Double_t TMVA::PDEFoam::GetSumCellIntg()
{
   // returns the sum of all cell integrals of all active cells
   Double_t intg = 0;
   for (Long_t iCell=0; iCell<=fLastCe; iCell++) {
      if (fCells[iCell]->GetStat())
         intg += fCells[iCell]->GetIntg();
   }
   return intg;
}

//_______________________________________________________________________________________________
UInt_t TMVA::PDEFoam::GetNActiveCells()
{
   // returns number of active cells
   UInt_t count = 0;
   for (Long_t iCell=0; iCell<=fLastCe; iCell++) {
      if (fCells[iCell]->GetStat())
         count++;
   }
   return count;
}

//_______________________________________________________________________________________________
void TMVA::PDEFoam::RemoveEmptyCell( Int_t iCell )
{
   // This function removes a cell iCell, which has a volume equal to zero.
   // It works the following way:
   // 1) find grandparent to iCell
   // 2) set daughter of the grandparent cell to the sister of iCell
   // Result:
   // iCell and its parent are alone standing ==> will be removed

   // get cell volume
   Double_t volume = fCells[iCell]->GetVolume();

   if (!fCells[iCell]->GetStat() || volume>0){
      Log() << "<RemoveEmptyCell>: cell " << iCell 
              << "is not active or has volume>0 ==> doesn't need to be removed" << Endl;
      return;
   }

   // get parent and grandparent Cells
   PDEFoamCell *pCell  = fCells[iCell]->GetPare();
   PDEFoamCell *ppCell = fCells[iCell]->GetPare()->GetPare();

   // get neighbour (sister) to iCell
   PDEFoamCell *sCell;
   if (pCell->GetDau0() == fCells[iCell])
      sCell = pCell->GetDau1();
   else
      sCell = pCell->GetDau0();

   // cross check
   if (pCell->GetIntg() != sCell->GetIntg())
      Log() << kWARNING << "<RemoveEmptyCell> Error: cell integrals are not equal!" 
              << " Intg(parent cell)=" << pCell->GetIntg() 
              << " Intg(sister cell)=" << sCell->GetIntg() 
              << Endl;

   // set daughter of grandparent to sister of iCell
   if (ppCell->GetDau0() == pCell)
      ppCell->SetDau0(sCell);
   else
      ppCell->SetDau1(sCell);

   // set parent of sister to grandparent of of iCell
   sCell->SetPare(ppCell);

   // now iCell and its parent are alone ==> set them inactive
   fCells[iCell]->SetStat(0);
   pCell->SetStat(0);
}

//_______________________________________________________________________________________________
void TMVA::PDEFoam::CheckCells( Bool_t remove_empty_cells )
{
   // debug function: checks all cells with respect to critical
   // values, f.e. cell volume, ...

   for (Long_t iCell=0; iCell<=fLastCe; iCell++) {
      if (!fCells[iCell]->GetStat())
         continue;

      Double_t volume = fCells[iCell]->GetVolume();
      if (volume<1e-10){
         if (volume<=0){
            Log() << kWARNING << "Critical: cell volume negative or zero! volume=" 
                    << volume << " cell number: " << iCell << Endl;
            // fCells[iCell]->Print("1"); // debug output
            if (remove_empty_cells){
               Log() << kWARNING << "Remove cell " << iCell << Endl;
               RemoveEmptyCell(iCell);
            }
         }
         else {
            Log() << kWARNING << "Cell volume close to zero! volume=" 
                    << volume << " cell number: " << iCell << Endl;
         }
      }
   }   
}

//_______________________________________________________________________________________________
void TMVA::PDEFoam::PrintCellElements()
{
   for (Long_t iCell=0; iCell<=fLastCe; iCell++) {
      if (!fCells[iCell]->GetStat()) continue;
      
      std::cout << ">>> cell[" << iCell << "] elements: ";
      for (UInt_t i=0; i<GetNElements(); i++)
         std::cout << "[" << i << "; " << GetCellElement(fCells[iCell], i) << "] ";
      std::cout << std::endl;
   }
}

//_______________________________________________________________________________________________
UInt_t TMVA::PDEFoam::GetNInActiveCells()
{
   // returns number of not active cells
   return GetNCells()-GetNActiveCells();
}

//_______________________________________________________________________________________________
UInt_t TMVA::PDEFoam::GetNCells()
{
   // returns the total number of foam cells (active and not active cells)
   return fNCells;
}

//_______________________________________________________________________________________________
Int_t TMVA::PDEFoam::GetSumCellMemory( ECellType ct )
{
   // returns total used memory of cells in bytes
   // The parameter 'ct' describes the cell type: 
   // - kAll - get memory usage of all cells
   // - kActive - get memory usage of all active cells
   // - kInActive - get memory usage of all non-active cells

   UInt_t count = 0;
   for (Long_t iCell=0; iCell<fNCells; iCell++) {
      Int_t cellsize = sizeof(*(fCells[iCell]));

      if (ct==kAll)
         count += cellsize;
      else if (ct==kActive && fCells[iCell]->GetStat() && iCell<fLastCe)
         count += cellsize;
      else if (ct==kInActive && 
               ((!(fCells[iCell]->GetStat()) && iCell<fLastCe) || iCell>=fLastCe) )
         count += cellsize;
   }
   return count;
}

//_______________________________________________________________________________________________
TMVA::PDEFoamCell* TMVA::PDEFoam::GetRootCell()
{
   // returns pointer to root cell
   return fCells[0];
}

//_______________________________________________________________________________________________
void TMVA::PDEFoam::ResetCellElements(Bool_t allcells)
{
   // creates a TVectorD object with fNElements in every cell
   // and initializes them by zero.
   // The TVectorD object is used to store classification or 
   // regression data in every foam cell.
   //
   // Parameter:
   //   allcells == true  : create TVectorD on every cell
   //   allcells == false : create TVectorD on active cells with 
   //                       cell index <= fLastCe (default)
   
   if (!fCells || GetNElements()==0) return;

   // delete all old cell elements
   Log() << kVERBOSE << "Delete old cell elements" << Endl;
   for(Long_t iCell=0; iCell<fNCells; iCell++) {
      if (fCells[iCell]->GetElement() != 0){
	 delete dynamic_cast<TVectorD*>(fCells[iCell]->GetElement());
         fCells[iCell]->SetElement(0);
      }
   }

   if (allcells){
      Log() << kVERBOSE << "Reset new cell elements to " 
	    << GetNElements() << " value(s) per cell" << Endl;
      // create new cell elements on every cell
      for(Long_t iCell=0; iCell<fNCells; iCell++) {
	 TVectorD *elem = new TVectorD(GetNElements());

	 for (UInt_t i=0; i<GetNElements(); i++)
	    (*elem)(i) = 0.;

	 fCells[iCell]->SetElement(elem);
      }   
   } else {
      Log() << kVERBOSE << "Reset active cell elements to " 
	    << GetNElements() << " value(s) per cell" << Endl;
      // create new cell elements (only active cells with 
      // cell index <= fLastCe)
      for(Long_t iCell=0; iCell<=fLastCe; iCell++) {
	 // skip inactive cells
	 if (!(fCells[iCell]->GetStat()))
	    continue;

	 TVectorD *elem = new TVectorD(GetNElements());

	 for (UInt_t i=0; i<GetNElements(); i++)
	    (*elem)(i) = 0.;

	 fCells[iCell]->SetElement(elem);
      }   
   }
}

//_______________________________________________________________________________________________
void TMVA::PDEFoam::DisplayCellContent()
{
   // prints out general cell informations
   Double_t total_counts = 0;
   Double_t max = GetCellEntries(fCells[0]);
   Double_t min = GetCellEntries(fCells[0]);

   // Reset Cell Integrals
   for (Long_t iCell=0; iCell<=fLastCe; iCell++) {
      total_counts += GetCellEntries(fCells[iCell]);
      
      if (GetCellEntries(fCells[iCell]) < min)
         min = GetCellEntries(fCells[iCell]);
      if (GetCellEntries(fCells[iCell]) > max)
         max = GetCellEntries(fCells[iCell]);
   }

   Log() << kVERBOSE << "DEBUG: Total Events in Foam: " << total_counts << Endl;
   Log() << kVERBOSE << "DEBUG: min cell entry: " << min << Endl;
   Log() << kVERBOSE << "DEBUG: max cell entry: " << max << Endl;
}

//_______________________________________________________________________________________________
void TMVA::PDEFoam::CalcCellTarget()
{
   // Calculate average cell target in every cell and save them to the cell.
   // This function is called when the Mono target regression option is set.

   // loop over cells
   for (Long_t iCell=0; iCell<=fLastCe; iCell++) {
      if (!(fCells[iCell]->GetStat()))
         continue;

      Double_t N_ev  = GetCellElement(fCells[iCell], 0); // get number of events
      Double_t tar   = GetCellElement(fCells[iCell], 1); // get sum of targets

      if (N_ev > 1e-10){
         SetCellElement(fCells[iCell], 0, tar/N_ev);  // set average target
         SetCellElement(fCells[iCell], 1, 0.0 );      // ???
      }
      else {
         SetCellElement(fCells[iCell], 0, 0.0 ); // set mean target
         SetCellElement(fCells[iCell], 1, 1.  ); // set mean target error
      }
   }
}

//_______________________________________________________________________________________________
void TMVA::PDEFoam::CalcCellDiscr()
{
   // Calc discriminator and its error for every cell and save it to the cell.
   // This function is called when the fSigBgSeparated==False option is set.

   // loop over cells
   for (Long_t iCell=0; iCell<=fLastCe; iCell++) {
      if (!(fCells[iCell]->GetStat()))
         continue;

      Double_t N_sig = GetCellElement(fCells[iCell], 0); // get number of signal events
      Double_t N_bg  = GetCellElement(fCells[iCell], 1); // get number of bg events

      if (N_sig<0.) {
	Log() << kWARNING << "Negative number of signal events in cell " << iCell 
	      << ": " << N_sig << ". Set to 0." << Endl;
	N_sig=0.;
      }
      if (N_bg<0.) {
	Log() << kWARNING << "Negative number of background events in cell " << iCell 
	      << ": " << N_bg << ". Set to 0." << Endl;
	N_bg=0.;
      }


      if (N_sig+N_bg > 1e-10){
         SetCellElement(fCells[iCell], 0, N_sig/(N_sig+N_bg));  // set discriminator
         SetCellElement(fCells[iCell], 1, TMath::Sqrt( TMath::Power ( N_sig/TMath::Power(N_sig+N_bg,2),2)*N_sig +
                                                       TMath::Power ( N_bg /TMath::Power(N_sig+N_bg,2),2)*N_bg ) ); // set discriminator error

      }
      else {
         SetCellElement(fCells[iCell], 0, 0.5); // set discriminator
         SetCellElement(fCells[iCell], 1, 1. ); // set discriminator error
      }
   }
}

//_______________________________________________________________________________________________
Double_t TMVA::PDEFoam::GetCellDiscr( std::vector<Float_t> xvec, EKernel kernel )
{
   // Get discriminator saved in cell (previously calculated in CalcCellDiscr())
   // which encloses the coordinates given in xvec.
   // This function is used, when the fSigBgSeparated==False option is set
   // (unified foams).

   Double_t result = 0.;

   // transform xvec
   std::vector<Float_t> txvec = VarTransform(xvec);

   // find cell
   PDEFoamCell *cell= FindCell(txvec);

   if (!cell) return -999.;

   if (kernel == kNone) result = GetCellDiscr(cell);
   else if (kernel == kGaus) {
      Double_t norm = 0.;

      for (Long_t iCell=0; iCell<=fLastCe; iCell++) {
         if (!(fCells[iCell]->GetStat())) continue;

         // calc cell density
         Double_t cell_discr = GetCellDiscr(fCells[iCell]);
         Double_t gau        = WeightGaus(fCells[iCell], txvec);

         result += gau * cell_discr;
         norm   += gau;
      }

      result /= norm;
   } 
   else if (kernel == kLinN) {
      result = WeightLinNeighbors(txvec, kDiscriminator);
   }
   else {
      Log() << kFATAL << "GetCellDiscr: ERROR: wrong kernel!" << Endl;
      result = -999.0;
   }

   return result;
}

//_______________________________________________________________________________________________
Double_t TMVA::PDEFoam::GetCellDiscrError( std::vector<Float_t> xvec )
{
   // Return discriminator error of cell (previously calculated in CalcCellDiscr()).
   // This function is used, when the fSigBgSeparated==False option is set
   // (unified foams).

   // find cell
   PDEFoamCell *cell= FindCell(VarTransform(xvec));
   if (!cell) return -999.;

   return GetCellDiscrError(cell);
}

//_______________________________________________________________________________________________
void TMVA::PDEFoam::FillFoamCells(const Event* ev, EFoamType ft, Bool_t NoNegWeights)
{
   // This function fills an event into the foam.
   //
   // In case of ft==kMonoTarget this function prepares the
   // calculation of the average target value in every cell.  Note,
   // that only target 0 is saved in the cell!
   //
   // In case of ft==kDiscr this function prepares the calculation of
   // the cell discriminator in every cell.
   //
   // If 'NoNegWeights' is true, an event with negative weight will
   // not be filled into the foam.  (Default value: false)

   std::vector<Float_t> values  = ev->GetValues();
   std::vector<Float_t> targets = ev->GetTargets();
   Float_t weight               = ev->GetOriginalWeight();
   
   if(NoNegWeights && weight<=0)
      return;

   if (ft == kMultiTarget)
      values.insert(values.end(), targets.begin(), targets.end());

   // find corresponding foam cell
   PDEFoamCell *cell = FindCell(VarTransform(values));
   if (!cell) {
      Log() << kFATAL << "<PDEFoam::FillFoamCells>: No cell found!" << Endl; 
      return;
   }

   // Add events to cell
   if (ft == kSeparate || ft == kMultiTarget){
      // 0. Element: Number of events
      // 1. Element: RMS
      SetCellElement(cell, 0, GetCellElement(cell, 0) + weight);
      SetCellElement(cell, 1, GetCellElement(cell, 1) + weight*weight);
   } else if (ft == kDiscr){
      // 0. Element: Number of signal events
      // 1. Element: Number of background events times normalization
      if (ev->IsSignal())
	 SetCellElement(cell, 0, GetCellElement(cell, 0) + weight);
      else
	 SetCellElement(cell, 1, GetCellElement(cell, 1) + weight);
   } else if (ft == kMonoTarget){
      // 0. Element: Number of events
      // 1. Element: Target 0
      SetCellElement(cell, 0, GetCellElement(cell, 0) + weight);
      SetCellElement(cell, 1, GetCellElement(cell, 1) + weight*targets.at(0));
   }   
}

//_______________________________________________________________________________________________
Double_t TMVA::PDEFoam::GetCellMean( std::vector<Float_t> xvec )
{  // Return mean of event distribution in cell that encloses xvec

   PDEFoamCell *cell = FindCell(VarTransform(xvec));

   if (!cell) {
      Log() << kFATAL << "<GetCellMean> ERROR: No cell found! " << Endl; 
      return -999.;
   }

   return GetCellMean(cell);
}

//_______________________________________________________________________________________________
Double_t TMVA::PDEFoam::GetCellRMS( std::vector<Float_t> xvec )
{  // Get RMS event distribution in cell that encloses xvec

   PDEFoamCell *cell = FindCell(VarTransform(xvec));

   if (!cell) {
      Log() << kFATAL << "<GetCellRMS> ERROR: No cell found! " << Endl; 
      return -999.;
   }

   return GetCellRMS(cell);
}

//_______________________________________________________________________________________________
Double_t TMVA::PDEFoam::GetCellRegValue0( std::vector<Float_t> xvec, EKernel kernel )
{  
   // Get regression value 0 from cell that contains xvec.
   // This function is used when the MultiTargetRegression==False option is set.

   Double_t result = 0.;

   std::vector<Float_t> txvec = VarTransform(xvec);
   PDEFoamCell *cell          = FindCell(txvec);

   if (!cell) {
      Log() << kFATAL << "<GetCellRegValue0> ERROR: No cell found!" << Endl; 
      return -999.;
   }

   if (kernel == kNone){
      result = GetCellRegValue0(cell);
   }
   else if (kernel == kGaus){
      // return gaus weighted cell density

      Double_t norm = 0.;
      for (Long_t iCell=0; iCell<=fLastCe; iCell++) {
         if (!(fCells[iCell]->GetStat())) continue;

         // calc cell density
         Double_t cell_val = GetCellRegValue0(fCells[iCell]);
         Double_t gau      = WeightGaus(fCells[iCell], txvec);

         result += gau * cell_val;
         norm   += gau;
      }
      result /= norm;
   }
   else if (kernel == kLinN) {
      result = WeightLinNeighbors(txvec, kTarget0);
   }
   else {
      Log() << kFATAL << "ERROR: unknown kernel!" << Endl; 
      return -999.;
   }

   return result;
}

//_______________________________________________________________________________________________
Double_t TMVA::PDEFoam::GetCellTarget( UInt_t target_number, std::vector<Float_t> tvals, ETargetSelection ts )
{
   // This function is used when the MultiTargetRegression==True
   // option is set.  It calculates the mean target or most probable
   // target value with the id 'target_number' if 'tvals' variables
   // are given ('tvals' does not contain targets)
   //
   // Parameters:
   // - tvals - transformed event variables (element of [0,1]) (no targets!)
   // - target_number - number of target (i.e. 0= first target)
   // - ts - method of target selection (kMean, kMpv)
   //
   // Result: 
   // mean target or most probable target over all cells which first
   // coordinates enclose 'tvals'
   
   Double_t result       = 0.;
   Double_t norm         = 0.;
   Double_t max_dens     = 0.;
   UInt_t   cell_count   = 0;
   const Double_t xsmall = 1.e-7; 

   if (ts==kMpv)
      result = fXmin[target_number+tvals.size()];

   // loop over all cells
   for (Long_t iCell=0; iCell<=fLastCe; iCell++) {
      if (!(fCells[iCell]->GetStat())) continue;

      // find cells which first coordinates (non-target coordinates)
      // fit with given variables 'tvals'
      PDEFoamVect  cellPosi(GetTotDim()), cellSize(GetTotDim());
      fCells[iCell]->GetHcub(cellPosi, cellSize);

      Bool_t CellOK = kTRUE;
      for (UInt_t k=0; k<tvals.size(); k++){
         if (!( tvals.at(k) >  cellPosi[k]-xsmall && 
		tvals.at(k) <= cellPosi[k]+cellSize[k]+xsmall )){
            CellOK = kFALSE;
            break;
         }
      }
      if (!CellOK)
         continue;
      cell_count++;

      // cell fits -> start projection
      Double_t cell_density = GetCellDensity(fCells[iCell]);

      if (ts==kMean){
	 // sum cell density times cell center
	 result += cell_density * VarTransformInvers(target_number+tvals.size(), 
						     cellPosi[target_number+tvals.size()]
						     +0.5*cellSize[target_number+tvals.size()]);
	 norm   += cell_density;
      } else {
	 // get cell center with maximum event density
	 if (cell_density > max_dens){
	    max_dens = cell_density;
	    result = VarTransformInvers(target_number+tvals.size(), 
					cellPosi[target_number+tvals.size()]
					+0.5*cellSize[target_number+tvals.size()]);
	 }
      }

   } // cell loop

   if (cell_count<1 || (ts==kMean && norm<1.0e-15))
      return (fXmax[target_number+tvals.size()]-fXmin[target_number+tvals.size()])/2.;

   // calc mean cell density
   if (ts==kMean)
      result /= norm;

   return result;
}

//_______________________________________________________________________________________________
Double_t TMVA::PDEFoam::GetProjectedRegValue( UInt_t target_number, std::vector<Float_t> vals, 
                                              EKernel kernel, ETargetSelection ts )
{
   // This function is used when the MultiTargetRegression==True option is set.
   // Returns regression value i, given the event variables 'vals'.
   // Note: number of foam dimensions = number of variables + number of targets
   //
   // Parameters:
   // - target_number - number of target (i.e. target_number=0 specifies the first target)
   // - vals - event variables (no targets)
   // - kernel - used kernel (None or Gaus)
   // - ts - method of target selection (Mean or Mpv)

   if (target_number+vals.size() > UInt_t(GetTotDim())){
      Log() << kFATAL << "ERROR: wrong dimension given!" << Endl;
      return 0;
   }

   // checkt whether vals are within foam borders.
   // if not -> push it into foam
   const Double_t xsmall = 1.e-7; 
   for (UInt_t l=0; l<vals.size(); l++) {
      if (vals.at(l) <= fXmin[l]){
         vals.at(l) = fXmin[l] + xsmall;
      }
      else if (vals.at(l) >= fXmax[l]){
         vals.at(l) = fXmax[l] - xsmall;
      }
   }
   
   // transform variables (vals)
   std::vector<Float_t> txvec = VarTransform(vals);

   // result value and norm
   Double_t result = 0.;

   // choose kernel
   /////////////////// no kernel //////////////////
   if (kernel == kNone)
      result = GetCellTarget(target_number, txvec, ts);
   ////////////////////// Gaus kernel //////////////////////
   else if (kernel == kGaus){

      Double_t norm = 0.;

      // loop over all active cells to calc gaus weighted target values
      for (Long_t ice=0; ice<=fLastCe; ice++) {
         if (!(fCells[ice]->GetStat())) continue;

	 // weight with gaus only in non-target dimensions!
         Double_t gau = WeightGaus(fCells[ice], txvec, vals.size());

         PDEFoamVect cellPosi(GetTotDim()), cellSize(GetTotDim());
         fCells[ice]->GetHcub(cellPosi, cellSize);

         // fill new vector with coordinates of new cell
         std::vector<Float_t> new_vec;
         for (UInt_t k=0; k<txvec.size(); k++)
            new_vec.push_back(cellPosi[k] + 0.5*cellSize[k]);

         Double_t val = GetCellTarget(target_number, new_vec, ts);
         result += gau * val;
         norm   += gau;
      }

      if (norm<1.0e-20){
         // evtl. change algorithm -> find nearest cell! (analogus to FindCell()?)
         Log() << kWARNING << "Warning: norm too small!" << Endl;
         return 0.;
      }

      result /= norm; // this variable now contains gaus weighted average target value
      
   } // end gaus kernel
   else {
      Log() << kFATAL << "<GetProjectedRegValue> ERROR: unsupported kernel!" << Endl;
      result = 0.;
   }

   return result;
} 

//_______________________________________________________________________________________________
Double_t TMVA::PDEFoam::GetCellEntries( std::vector<Float_t> xvec )
{  // Returns number of events in cell that encloses xvec

   PDEFoamCell *cell= FindCell(VarTransform(xvec));

   if (!cell) {
      Log() << kFATAL << "<GetCellEntries> No cell found! " << Endl; 
      return -999.;
   }

   return GetCellEntries(cell);
}

//_______________________________________________________________________________________________
Double_t TMVA::PDEFoam::GetCellDensity( PDEFoamCell *cell )
{
   // Returns cell density = number of events in cell / cell volume

   Double_t volume  = cell->GetVolume();
   Double_t entries = GetCellEntries(cell);
   if (entries <= 0)
      return 0.;
   if (volume > 1.0e-10 ){
      return GetCellEntries(cell)/volume;
   }
   else {
      if (volume<=0){
         cell->Print("1"); // debug output
         Log() << kWARNING << "<GetCellDensity(cell)>: ERROR: cell volume negative or zero!"
                 << " ==> return cell density 0!" 
                 << " cell volume=" << volume 
                 << " cell entries=" << GetCellEntries(cell) << Endl;
         return 0;
      }
      else {
         Log() << kWARNING << "<GetCellDensity(cell)>: WARNING: cell volume close to zero!" 
                 << " cell volume: " << volume << Endl;
      }
   }
   return GetCellEntries(cell)/volume;   
}

//_______________________________________________________________________________________________
Double_t TMVA::PDEFoam::GetCellDensity( std::vector<Float_t> xvec, EKernel kernel )
{ 
   // Returns density (=number of entries / volume) of cell that encloses 'xvec'.
   // This function is called by GetMvaValue() in case of two separated foams
   // (signal and background).
   // 'kernel' can be either kNone or kGaus.

   Double_t result = 0;
   std::vector<Float_t> txvec = VarTransform(xvec);
   PDEFoamCell *cell          = FindCell(txvec);

   if (!cell) {
      Log() << kFATAL << "<GetCellDensity(event)> ERROR: No cell found!" << Endl; 
      return -999.;
   }

   if (kernel == kNone){
      // return cell entries over cell volume
      return GetCellDensity(cell);
   }
   else if (kernel == kGaus){
      // return gaus weighted cell density

      Double_t norm = 0.;

      for (Long_t iCell=0; iCell<=fLastCe; iCell++) {
         if (!(fCells[iCell]->GetStat())) continue;

         // calc cell density
         Double_t cell_dens = GetCellDensity(fCells[iCell]);
         Double_t gau       = WeightGaus(fCells[iCell], txvec);

         result += gau * cell_dens;
         norm   += gau;
      }

      result /= norm;
   }
   else if (kernel == kLinN){
      result = WeightLinNeighbors(txvec, kDensity);
   }
   else {
      Log() << kFATAL << "<GetCellDensity(event)> ERROR: unknown kernel!" << Endl; 
      return -999.;
   }

   return result;
}

//_______________________________________________________________________________________________
Double_t TMVA::PDEFoam::GetCellRegValue0( PDEFoamCell* cell )
{
   // Returns the content of cell element 0, in which the average target value 
   // (target 0) is saved.
   // Only used if MultiTargetRegression==False.
   return GetCellElement(cell, 0);
}

//_______________________________________________________________________________________________
Double_t TMVA::PDEFoam::GetCellDiscr( PDEFoamCell* cell )
{
   // Returns the content of cell element 0, in which the cell discriminator is saved.
   // Only used if fSigBgSeparated==False.
   return GetCellElement(cell, 0);
}

//_______________________________________________________________________________________________
Double_t TMVA::PDEFoam::GetCellDiscrError( PDEFoamCell* cell )
{
   // Returns the content of cell element 1, in which the cell discriminator error is saved.
   // Only used if fSigBgSeparated==False.
   return GetCellElement(cell, 1);
}

//_______________________________________________________________________________________________
Double_t TMVA::PDEFoam::GetCellMean( PDEFoamCell* cell )
{
   // Returns the mean of the event distribution in the 'cell'.
   // Only used if fSigBgSeparated==True.
   return cell->GetIntg();
}

//_______________________________________________________________________________________________
Double_t TMVA::PDEFoam::GetCellRMS( PDEFoamCell* cell )
{
   // Returns the RMS of the event distribution in the 'cell'.
   // Only used if fSigBgSeparated==True.
   return cell->GetDriv();
}

//_______________________________________________________________________________________________
Double_t TMVA::PDEFoam::GetCellRMSovMean( PDEFoamCell* cell )
{
   // returns RMS/Mean for given cell
   if (GetCellMean(cell)!=0)
      return GetCellRMS(cell)/GetCellMean(cell);
   else
      return 0;
}

//_______________________________________________________________________________________________
Double_t TMVA::PDEFoam::GetCellEntries( PDEFoamCell* cell )
{
   // Returns the number of events, saved in the 'cell'.
   // Only used if fSigBgSeparated==True.
   return GetCellElement(cell, 0);
}

//_______________________________________________________________________________________________
Double_t TMVA::PDEFoam::GetCellEvents( PDEFoamCell* cell )
{
   // Returns the number of events, saved in the 'cell' during foam build-up.
   // Only used during foam build-up!
   return GetCellElement(cell, 0);
}

//_______________________________________________________________________________________________
Double_t TMVA::PDEFoam::WeightLinNeighbors( std::vector<Float_t> txvec, ECellValue cv )
{ 
   // results the cell value, corresponding to txvec, weighted by the
   // neighor cells via a linear function
   //
   // Parameters
   //  - txvec - event vector, transformed to interval [0,1]
   //  - cv - cell value to be weighted

   Double_t result = 0.;
   const Double_t xoffset = 1.e-6; 

   if (txvec.size() != UInt_t(GetTotDim()))
      Log() << kFATAL << "Wrong dimension of event variable!" << Endl;

   PDEFoamCell *cell= FindCell(txvec);
   PDEFoamVect cellSize(GetTotDim());
   PDEFoamVect cellPosi(GetTotDim());
   cell->GetHcub(cellPosi, cellSize);

   for (Int_t dim=0; dim<GetTotDim(); dim++) {
      std::vector<Float_t> ntxvec = txvec;
      Double_t mindist;
      PDEFoamCell *mindistcell = 0;
      mindist = (txvec[dim]-cellPosi[dim])/cellSize[dim];
      if (mindist<0.5) { // left neighbour 
	 ntxvec[dim] = cellPosi[dim]-xoffset;
	 mindistcell = FindCell(ntxvec);
      } else { // right neighbour
	 mindist=1-mindist;
	 ntxvec[dim] = cellPosi[dim]+cellSize[dim]+xoffset;
	 mindistcell = FindCell(ntxvec);	 
      }
      Double_t cellval = 0;
      Double_t mindistcellval = 0;
      if (cv==kDiscriminator){
	 cellval        = GetCellDiscr(cell);
	 mindistcellval = GetCellDiscr(mindistcell);
      } else if (cv==kTarget0){
	 cellval        = GetCellRegValue0(cell);
	 mindistcellval = GetCellRegValue0(mindistcell);
      } else if (cv==kDensity){
	 cellval        = GetCellDensity(cell);
	 mindistcellval = GetCellDensity(mindistcell);
      } else if (cv==kNev){
	 cellval        = GetCellEntries(cell);
	 mindistcellval = GetCellEntries(mindistcell);
      } else if (cv==kMeanValue){
	 cellval        = GetCellMean(cell);
	 mindistcellval = GetCellMean(mindistcell);
      } else if (cv==kRms){
	 cellval        = GetCellRMS(cell);
	 mindistcellval = GetCellRMS(mindistcell);
      } else if (cv==kRmsOvMean){
	 cellval        = GetCellRMSovMean(cell);
	 mindistcellval = GetCellRMSovMean(mindistcell);
      } else {
	 Log() << kFATAL << "<WeightLinNeighbors>: unsupported option" << Endl;
      }
      result += cellval        * (0.5 + mindist);
      result += mindistcellval * (0.5 - mindist);
   }
   return result/GetTotDim();
}

//_______________________________________________________________________________________________
Double_t TMVA::PDEFoam::WeightGaus( PDEFoamCell* cell, std::vector<Float_t> txvec, UInt_t dim )
{ 
   // Returns the gauss weight between the 'cell' and a given coordinate 'txvec'.
   //
   // Parameters:
   // - cell - the cell
   // - txvec - the transformed event variables (in [0,1]) (coordinates <0 are set to 0, >1 are set to 1)
   // - dim - number of dimensions for the calculation of the euclidean distance.
   //   If dim=0, all dimensions of the foam are taken.  Else only the first 'dim'
   //   coordinates of 'txvec' are used for the calculation of the euclidean distance.
   //
   // Returns:
   // exp(-(d/sigma)^2/2), where 
   //  - d - is the euclidean distance between 'txvec' and the point of the 'cell'
   //    which is most close to 'txvec' (in order to avoid artefacts because of the 
   //    form of the cells).
   //  - sigma = 1/VolFrac

   // get cell coordinates
   PDEFoamVect cellSize(GetTotDim());
   PDEFoamVect cellPosi(GetTotDim());
   cell->GetHcub(cellPosi, cellSize);

   // calc normalized distance
   UInt_t dims;            // number of dimensions for gaus weighting
   if (dim == 0) 
      dims = GetTotDim();  // use all dimensions of cell txvec for weighting
   else if (dim <= UInt_t(GetTotDim()))
      dims = dim;          // use only 'dim' dimensions of cell txvec for weighting
   else {
      Log() << kFATAL << "ERROR: too many given dimensions for Gaus weight!" << Endl;
      return 0.;
   }

   // calc position of nearest edge of cell
   std::vector<Float_t> cell_center;
   for (UInt_t i=0; i<dims; i++){
     if (txvec[i]<0.) txvec[i]=0.;
     if (txvec[i]>1.) txvec[i]=1.;
      //cell_center.push_back(cellPosi[i] + (0.5*cellSize[i]));
      if (cellPosi[i] > txvec.at(i))
         cell_center.push_back(cellPosi[i]);
      else if (cellPosi[i]+cellSize[i] < txvec.at(i))
         cell_center.push_back(cellPosi[i]+cellSize[i]);
      else
         cell_center.push_back(txvec.at(i));
   }

   Double_t distance = 0.; // distance for weighting
   for (UInt_t i=0; i<dims; i++)
      distance += TMath::Power(txvec.at(i)-cell_center.at(i), 2);
   distance = TMath::Sqrt(distance);

   Double_t width = 1./GetPDEFoamVolumeFraction();
   if (width < 1.0e-10) 
      Log() << kWARNING << "Warning: wrong volume fraction: " << GetPDEFoamVolumeFraction() << Endl;
   
   // weight with Gaus with sigma = 1/VolFrac
   return TMath::Gaus(distance, 0, width, kFALSE);
}

//_______________________________________________________________________________________________
TMVA::PDEFoamCell* TMVA::PDEFoam::FindCell( std::vector<Float_t> xvec )
{
   // Find cell that contains xvec
   //
   // loop to find cell that contains xvec
   // start from root Cell, uses binary tree to
   // find cell quickly
   //
   // DD 10.12.2007 
   // cleaned up a bit and improved performance

   PDEFoamVect  cellPosi0(GetTotDim()), cellSize0(GetTotDim());
   PDEFoamCell *cell, *cell0;

   cell=fCells[0]; // start with root cell
   Int_t idim=0;
   while (cell->GetStat()!=1) { //go down binary tree until cell is found
      idim=cell->GetBest();  // dimension that changed
      cell0=cell->GetDau0(); 
      cell0->GetHcub(cellPosi0,cellSize0);

      if (xvec.at(idim)<=cellPosi0[idim]+cellSize0[idim])
         cell=cell0;
      else
         cell=(cell->GetDau1());
   } 
   return cell;
}

//_________________________________________________________________________________________
TH1D* TMVA::PDEFoam::Draw1Dim( const char *opt, Int_t nbin ) 
{
   // Draws 1-dimensional foam (= histogram)
   //
   // Parameters:
   // - opt - "mean", "nev", "rms", "rms_ov_mean", "discr" , "discr_error",
   //         "MonoTargetRegression", "MultiTargetRegression"
   // - nbin - number of bins of result histogram
   //
   // Warning: This function is not well tested!

   if (!(strcmp(opt,"mean")==0 || 
	 strcmp(opt,"nev")==0 || 
	 strcmp(opt,"rms")==0 || 
	 strcmp(opt,"rms_ov_mean")==0 || 
	 strcmp(opt,"discr")==0 || 
	 strcmp(opt,"discr_error")==0 ||
         strcmp(opt,"MonoTargetRegression")==0 || 
         strcmp(opt,"MultiTargetRegression")==0) || 
       GetTotDim()!=1 )
      return 0;

   char hname[100]; char htit[100];
   sprintf(htit,"1-dimensional Foam: %s", opt);
   sprintf(hname,"h%s",opt);

   TH1D* h1=(TH1D*)gDirectory->Get(hname);
   if (h1) delete h1;
   h1= new TH1D(hname, htit, nbin, fXmin[0], fXmax[0]);

   if (!h1) Log() << kFATAL << "ERROR: Can not create histo" << hname << Endl;

   std::vector<Float_t> xvec(GetTotDim(), 0.);

   // loop over all bins
   for (Int_t ibinx=1; ibinx<=nbin; ibinx++) { //loop over  x-bins
      xvec.at(0) = h1->GetBinCenter(ibinx);

      // transform xvec
      std::vector<Float_t> txvec = VarTransform(xvec);

      // loop over all active cells
      for (Long_t iCell=0; iCell<=fLastCe; iCell++) { 
         if (!(fCells[iCell]->GetStat())) continue; // cell not active -> continue
	    
         // get cell position and dimesions
         PDEFoamVect  cellPosi(GetTotDim()), cellSize(GetTotDim());
         fCells[iCell]->GetHcub(cellPosi,cellSize);

         // compare them with txvec
         const Double_t xsmall = 1.e-10; 
         if (!( (txvec.at(0)>cellPosi[0]-xsmall) && 
		(txvec.at(0)<=cellPosi[0]+cellSize[0]+xsmall) ) )
            continue; 

         Double_t vol = fCells[iCell]->GetVolume();
         if (vol<1e-10) {
            Log() << kWARNING << "Project: ERROR: Volume too small!" << Endl; 
            continue;
         }

         // get cell value (depending on the option)
         Double_t var = 0.;

         if (strcmp(opt,"nev")==0 || strcmp(opt,"MultiTargetRegression")==0)
            var = GetCellEntries(fCells[iCell]); 
         else if (strcmp(opt,"mean")==0)
            var = GetCellMean(fCells[iCell]); 
         else if (strcmp(opt,"rms")==0) 
            var = GetCellRMS(fCells[iCell]);
         else if (strcmp(opt,"rms_ov_mean")==0) 
            var = GetCellRMSovMean(fCells[iCell]);
         else if (strcmp(opt,"discr")==0)
            var = GetCellDiscr(fCells[iCell]);
         else if (strcmp(opt,"discr_error")==0)
            var = GetCellDiscrError(fCells[iCell]);
	 else if (strcmp(opt,"MonoTargetRegression")==0)
	    var = GetCellRegValue0(fCells[iCell]); 
         else
            Log() << kFATAL << "Project: ERROR: unknown option: " << opt << Endl;

         // filling value to histogram
         h1->SetBinContent(ibinx, var + h1->GetBinContent(ibinx));
      }
   }
   return h1;
}

//_________________________________________________________________________________________
TH2D* TMVA::PDEFoam::Project2( Int_t idim1, Int_t idim2, const char *opt, const char *ker, UInt_t maxbins )
{ 
   // Project foam variable idim1 and variable idim2 to histogram.
   //
   // Parameters:
   // - idim1, idim2 - variables to project to
   // - opt - rms, rms_ov_mean, nev, discr, MonoTargetRegression, MultiTargetRegression
   // - ker - kGaus, kNone (warning: Gaus may be very slow!)
   // - maxbins - maximal number of bins in result histogram.
   //   Set maxbins to 0 if no maximum bin number should be used.
   //
   // Returns:
   // a 2-dimensional histogram

   if (!(// strcmp(opt,"mean")==0  || 
         strcmp(opt,"nev")==0   || 
         strcmp(opt,"rms")==0   || 
         strcmp(opt,"rms_ov_mean")==0   || 
         strcmp(opt,"discr")==0 || 
         //strcmp(opt,"discr_error")==0 || 
         strcmp(opt,"MonoTargetRegression")==0 || 
         strcmp(opt,"MultiTargetRegression")==0) || 
       (idim1>=GetTotDim()) || (idim1<0) || 
       (idim2>=GetTotDim()) || (idim2<0) ||
       (idim1==idim2) )
      return 0;

   EKernel kernel = kNone;
   if (!strcmp(ker, "kNone"))
      kernel = kNone;
   else if (!strcmp(ker, "kGaus"))
      kernel = kGaus;
   else
      Log() << kWARNING << "Warning: wrong kernel! using kNone instead" << Endl;

   char name[]="PDEFoam::Project: ";
   const Bool_t debug = kFALSE;
   char hname[100]; char htit[100];
   const Double_t foam_area = (fXmax[idim1]-fXmin[idim1])*(fXmax[idim2]-fXmin[idim2]);
   Double_t bin_width = 1.; // minimal size of cell
 
   // loop over all cells to determine minimal cell size -> use for bin width
   for (Long_t iCell=0; iCell<=fLastCe; iCell++) { // loop over all active cells
      if (!(fCells[iCell]->GetStat())) continue;   // cell not active -> continue
      // get cell position and dimesions
      PDEFoamVect  cellPosi(GetTotDim()), cellSize(GetTotDim());
      fCells[iCell]->GetHcub(cellPosi,cellSize);
      // loop over all dimensions and determine minimal cell size
      for (Int_t d1=0; d1<GetTotDim(); d1++)
         if (cellSize[d1]<bin_width && cellSize[d1]>0)
            bin_width = cellSize[d1];
   }
   UInt_t nbin = UInt_t(1./bin_width);  // calculate number of bins

   if (maxbins>0 && nbin>maxbins) // limit maximum number of bins
      nbin = maxbins;

   // root can not handle too many bins in one histogram --> catch this
   // Furthermore, to have more than 1000 bins in the histogram doesn't make 
   // sense.
   if (nbin>1000){
      Log() << kWARNING << "Warning: number of bins too big: " << nbin 
              << "! Using 1000 bins for each dimension instead." << Endl;
      nbin = 1000;
   }
   
   // create result histogram
   sprintf(htit,"%s var%d vs var%d",opt,idim1,idim2);
   sprintf(hname,"h%s_%d_vs_%d",opt,idim1,idim2);
   if (debug) {
      Log() << kInfo <<name<<" Project var"<<idim1<<" and var"<<idim2<<" to histo: "<< Endl; 
      Log() << kVERBOSE <<name<<hname<<" nbin="<<nbin
              <<" fXmin["<<idim1<<"]="<<fXmin[idim1]<<" fXmax["<<idim1<<"]="<<fXmax[idim1]
              <<" fXmin["<<idim2<<"]="<<fXmin[idim2]<<" fXmax["<<idim2<<"]="<<fXmax[idim2]
              << Endl;
   }

   TH2D* h1=(TH2D*)gDirectory->Get(hname);
   if (h1) delete h1;
   h1= new TH2D(hname, htit, nbin, fXmin[idim1], fXmax[idim1], nbin, fXmin[idim2], fXmax[idim2]);

   if (!h1) Log() << kFATAL <<name<<"ERROR: Can not create histo"<<hname<< Endl;
   else if (debug) h1->Print();

   if (debug) Log() << kVERBOSE << "histogram created/ loaded" << Endl;

   // init cell counter (debug)
   UInt_t cell_count = 0;

   // start projection algorithm:
   // loop over all cells
   for (Long_t iCell=0; iCell<=fLastCe; iCell++) { // loop over all active cells
      if (!(fCells[iCell]->GetStat())) continue;   // cell not active -> continue
      cell_count++;
    
      // get cell position and dimesions
      PDEFoamVect  cellPosi(GetTotDim()), cellSize(GetTotDim());
      fCells[iCell]->GetHcub(cellPosi,cellSize);
 
      // init cell value (depending on the option)
      // this value will later be filled into the histogram
      Double_t var = 0.;

      // calculate value (depending on the given option 'opt')
      // =========================================================
      if (strcmp(opt,"mean")==0 || strcmp(opt,"nev")==0 || strcmp(opt,"MultiTargetRegression")==0){
         // calculate projected area of cell
         Double_t area = cellSize[idim1] * cellSize[idim2];
         if (area<1e-20){
            Log() << kWARNING << "PDEFoam::ProjectEvents: Warning, cell volume too small --> skiping cell!" 
                    << Endl;
            continue;
         }

         // calc cell entries per projected cell area
         if (strcmp(opt,"mean")==0)
            var = GetCellMean(fCells[iCell])/(area*foam_area); 
         else
            var = GetCellEntries(fCells[iCell])/(area*foam_area); 

         if (debug)
            Log() << kVERBOSE << "Project2: Cell=" << iCell << " projected density="  << var 
                    << " area=" << area*foam_area 
                    << " entries="<< GetCellEntries(fCells[iCell]) << Endl;
      }
      // =========================================================
      else if (strcmp(opt,"rms")==0){
         var = GetCellRMS(fCells[iCell]);
      }
      // =========================================================
      else if (strcmp(opt,"rms_ov_mean")==0){
         var = GetCellRMSovMean(fCells[iCell]);
      }
      // =========================================================
      else if (strcmp(opt,"discr")==0){
         // calculate cell volume in other dimensions (not including idim1 and idim2)
         Double_t area_cell = 1.;	       
         for (Int_t d1=0; d1<GetTotDim(); d1++){
            if ((d1!=idim1) && (d1!=idim2))
               area_cell *= cellSize[d1];
         }
         if (area_cell<1e-20){
            Log() << kWARNING << "ProjectEvents: Warning, cell volume too small --> skiping cell!" << Endl;
            continue;
         }
	 
         // calc discriminator * (cell area times foam area)
         var = GetCellDiscr(fCells[iCell])*area_cell;  // foam is normalized ->  length of foam = 1.0
      }
      // =========================================================
      else if (strcmp(opt,"discr_error")==0){
         var = GetCellDiscrError(fCells[iCell]);  // not testet jet!
      }
      // =========================================================
      else if (strcmp(opt,"MonoTargetRegression")==0){ // plot mean over all underlying cells?
         var = GetCellRegValue0(fCells[iCell]); 
      }
      else
         Log() << kFATAL << "Project: ERROR: unknown option: " << opt << Endl;

      const Double_t xsmall = (1.e-20)*cellSize[idim1];
      const Double_t ysmall = (1.e-20)*cellSize[idim2];

      Double_t x1 = VarTransformInvers( idim1, cellPosi[idim1]+xsmall );
      Double_t y1 = VarTransformInvers( idim2, cellPosi[idim2]+ysmall );
      
      Double_t x2 = VarTransformInvers( idim1, cellPosi[idim1]+cellSize[idim1]-xsmall );
      Double_t y2 = VarTransformInvers( idim2, cellPosi[idim2]+cellSize[idim2]-ysmall );

      Int_t xbin_start = h1->GetXaxis()->FindBin(x1);
      Int_t xbin_stop  = h1->GetXaxis()->FindBin(x2);

      Int_t ybin_start = h1->GetYaxis()->FindBin(y1);
      Int_t ybin_stop  = h1->GetYaxis()->FindBin(y2);

      // loop over all bins
      for (Int_t ibinx=xbin_start; ibinx<xbin_stop; ibinx++) {    //loop over x-bins
         for (Int_t ibiny=ybin_start; ibiny<ybin_stop; ibiny++) { //loop over y-bins

            ////////////////////// weight with kernel ///////////////////////
            if (kernel != kNone){
               Double_t result = 0.;
               Double_t norm   = 0.;

               // calc current position (depending on ibinx, ibiny)
               Double_t x_curr = VarTransform( idim1, ((x2-x1)*ibinx - x2*xbin_start + x1*xbin_stop)/(xbin_stop-xbin_start) );
               Double_t y_curr = VarTransform( idim2, ((y2-y1)*ibiny - y2*ybin_start + y1*ybin_stop)/(ybin_stop-ybin_start) );

               // loop over all cells
               for (Long_t ice=0; ice<=fLastCe; ice++) {
                  if (!(fCells[ice]->GetStat())) continue;

                  // get cell value (depending on option)
                  Double_t cell_var = 0.;
                  if (strcmp(opt,"mean")==0 || strcmp(opt,"nev")==0 || strcmp(opt,"MultiTargetRegression")==0){
                     PDEFoamVect  _cellPosi(GetTotDim()), _cellSize(GetTotDim());
                     fCells[ice]->GetHcub(_cellPosi, _cellSize);
                     Double_t cellarea = _cellSize[idim1] * _cellSize[idim2];
                     cell_var = GetCellEntries(fCells[ice])/(cellarea*foam_area); 
                  }
                  else if (strcmp(opt,"MonoTargetRegression")==0){
                     // PDEFoamVect  _cellPosi(GetTotDim()), _cellSize(GetTotDim());
                     // fCells[ice]->GetHcub(_cellPosi, _cellSize);
                     cell_var = GetCellRegValue0(fCells[ice]); 
                  }
                  else if (strcmp(opt,"rms")==0) 
                     cell_var = GetCellRMS(fCells[ice]);
                  else if (strcmp(opt,"rms_ov_mean")==0) 
                     cell_var = GetCellRMSovMean(fCells[ice]);
                  else if (strcmp(opt,"discr")==0){
                     PDEFoamVect  _cellPosi(GetTotDim()), _cellSize(GetTotDim());
                     fCells[ice]->GetHcub(_cellPosi, _cellSize);
                     Double_t cellarea = 1.;	       
                     for (Int_t d1=0; d1<GetTotDim(); d1++){
                        if ((d1!=idim1) && (d1!=idim2))
                           cellarea *= _cellSize[d1];
                     }	 
                     cell_var = GetCellDiscr(fCells[ice])*cellarea;
                  }
                  else if (strcmp(opt,"discr_error")==0)
                     cell_var = GetCellDiscrError(fCells[ice]);  // not testet jet!
                  else {
                     Log() << kFATAL << "ERROR: unsupported option for kernel plot!" << Endl;
                     return 0;
                  }
		  
                  // fill ndim coordinate of current cell
                  //Double_t coor[GetTotDim()];
                  std::vector<Float_t> coor;
                  for (Int_t i=0; i<GetTotDim(); i++) {
                     if (i == idim1)
                        coor.push_back(x_curr);
                     else if (i == idim2)
                        coor.push_back(y_curr);
                     else
                        coor.push_back(cellPosi[i] + 0.5*cellSize[i]); // approximation
                  }
		  
                  // calc weighted value
                  Double_t weight_ = 0;
                  if (kernel == kGaus)
                     weight_ = WeightGaus(fCells[ice], coor);
                  else 
                     weight_ = 1.;

                  result += weight_ * cell_var;
                  norm   += weight_;
               }
               var = result/norm;
            }
            ////////////////////// END weight with kernel ///////////////////////

            // filling value to histogram
            h1->SetBinContent(ibinx, ibiny, var + h1->GetBinContent(ibinx, ibiny));

            if (debug) {
               Log() << kVERBOSE << " ibinx=" << ibinx << " ibiny=" << ibiny 
                       << " cellID=" << iCell
                       << " [x1,y1]=[" << x1 << ", " << y1 <<"]"
                       << " [x2,y2]=[" << x2 << ", " << y2 <<"] value=" << var << Endl; 
            }
         } // y-loop
      } // x-loop
   } // cell loop

   Log() << kVERBOSE << "Info: Foam has " << cell_count << " active cells" << Endl;

   return h1;
}

//_________________________________________________________________________________________
TH2D* TMVA::PDEFoam::ProjectMC( Int_t idim1, Int_t idim2, Int_t nevents, Int_t nbin )
{  
   // Project variable idim1 and variable idim2 to histogram by using 
   // foams build in MC generation.
   //
   // Parameters:
   // - nevents - number of events to generate
   // - nbin - number of bins of returned histogram
   // - idim1, idim2 - foam variables (dimensions) to project to

   Bool_t debug = kFALSE;

   char hname[100]; char htit[100];
   sprintf(htit,"MC projection var%d vs var%d", idim1, idim2);
   sprintf(hname,"hMCProjections_%d_vs_%d",     idim1, idim2);
   
   TH2D* h1 = (TH2D*)gDirectory->Get(hname);
   if (h1) delete h1;
   h1= new TH2D(hname, htit, nbin, fXmin[idim1], fXmax[idim1], nbin, fXmin[idim2], fXmax[idim2]);

   Double_t *MCvect = new Double_t[GetTotDim()];
   Double_t wt=0.;
   
   // debug output:
   if (debug)
      Log() << kVERBOSE << "frho=" << fRho << " fPseRan=" << fPseRan << Endl;

   // generate MC events according to foam
   for (Long_t loop=0; loop<nevents; loop++){
      MakeEvent();
      GetMCvect(MCvect);
      GetMCwt(wt);
      h1->Fill(MCvect[idim1], MCvect[idim2], wt);
   }

   return h1;
}

//_________________________________________________________________________________________
TVectorD* TMVA::PDEFoam::GetCellElements( std::vector<Float_t> xvec )
{
   // Returns pointer to cell elements.

   if (unsigned(GetTotDim()) != xvec.size()){
      Log() << kFATAL << "ERROR: dimension of foam not equal to cell vector!" << Endl;
      return 0;
   }

   // find cell
   PDEFoamCell *cell= FindCell(VarTransform(xvec));

   if (!cell){ 
      Log() << kFATAL << "ERROR: cell not found!" << Endl;
      return 0; 
   }

   return dynamic_cast<TVectorD*>(cell->GetElement());
}

//_________________________________________________________________________________________
Double_t TMVA::PDEFoam::GetCellElement( PDEFoamCell *cell, UInt_t i )
{
   // Returns cell element i of cell 'cell'.

//    if (!(cell->GetStat()))
//       Log() << kWARNING << "PDEFoam::GetCellElement(): ERROR: Cell is inactive!" << Endl;

   if (i >= GetNElements()){
      Log() << kFATAL << "PDEFoam: ERROR: Index out of range" << Endl;
      return 0.;
   }      
   
   TVectorD *vec = dynamic_cast<TVectorD*>(cell->GetElement());

   if (!vec){
      Log() << kFATAL << "<GetCellElement> ERROR: cell element is not a TVectorD*" << Endl;
      return 0.;
   }

   return (*vec)(i);
}

//_________________________________________________________________________________________
void TMVA::PDEFoam::SetCellElement( PDEFoamCell *cell, UInt_t i, Double_t value )
{
   // Set cell element i of cell to value.

   if (i >= GetNElements()){
      Log() << kFATAL << "ERROR: Index out of range" << Endl;
      return;
   }      
   
   TVectorD *vec = dynamic_cast<TVectorD*>(cell->GetElement());

   if (!vec){
      Log() << kFATAL << "<SetCellElement> ERROR: cell element is not a TVectorD*" << Endl;
      return;
   }

   (*vec)(i) = value;
}

//_________________________________________________________________________________________
void TMVA::PDEFoam::OutputGrow( Bool_t finished )
{
   // Overridden function of PDEFoam to avoid native foam output.
   // Draw TMVA-process bar instead.

   if (finished) {
      Log() << kINFO << "Elapsed time: " + fTimer->GetElapsedTime() +  "                                 " << Endl;
      return;
   }

   Int_t modulo = 1;

   if (fNCells        >= 100) modulo = Int_t(fNCells/100);
   if (fLastCe%modulo == 0)   fTimer->DrawProgressBar( fLastCe );
}

//_________________________________________________________________________________________
void TMVA::PDEFoam::RootPlot2dim( const TString& filename, std::string what, 
                                  Bool_t CreateCanvas, Bool_t colors, Bool_t log_colors )
{
   // Debugging tool which plots 2-dimensional cells as rectangles
   // in C++ format readable for root.
   //
   // Parameters: 
   // - filename - filename of ouput root macro
   // - CreateCanvas - whether to create a new canvas or not

   Bool_t plotmean = kFALSE;
   Bool_t plotnevents = kFALSE;
   Bool_t plotdensity = kFALSE;   // plot event density
   Bool_t plotrms = kFALSE;
   Bool_t plotrmsovmean = kFALSE;
   Bool_t plotcellnumber = kFALSE;
   Bool_t plotdiscr = kFALSE;     // plot discriminator (Tancredi Carli's Method)
   Bool_t plotdiscrerr = kFALSE;  // plot discriminator error (Tancredi Carli's Method)
   Bool_t plotmonotarget = kFALSE; // target value for monotarget regression
   Bool_t fillcells = kTRUE;

   if (what == "mean")
      plotmean = kTRUE;
   else if (what == "nevents")
      plotnevents = kTRUE;
   else if (what == "density")
      plotdensity = kTRUE;
   else if (what == "rms")
      plotrms = kTRUE;
   else if (what == "rms_ov_mean")
      plotrmsovmean = kTRUE;
   else if (what == "cellnumber")
      plotcellnumber = kTRUE;
   else if (what == "discr")
      plotdiscr = kTRUE;
   else if (what == "discrerr")
      plotdiscrerr = kTRUE;
   else if (what == "monotarget")
      plotmonotarget = kTRUE;
   else if (what == "nofill") {
      plotcellnumber = kTRUE;
      fillcells = kFALSE;
   }
   else {
      plotmean = kTRUE;
      Log() << kWARNING << "Unknown option, plotting mean!" << Endl;
   }

   //    std::cerr << "fLastCe=" << fLastCe << std::endl;

   std::ofstream outfile(filename, std::ios::out);
   Double_t x1,y1,x2,y2,x,y;
   Long_t   iCell;
   Double_t offs =0.01;
   //   Double_t offs =0.1;
   Double_t lpag   =1-2*offs;
   outfile<<"{" << std::endl;
   //outfile<<"cMap = new TCanvas(\"Map1\",\" Cell Map \",600,600);"<<std::endl;
   if (!colors) {   // define grayscale colors from light to dark, starting from color index 1000
      outfile << "TColor *graycolors[100];" << std::endl;
      outfile << "for (Int_t i=0.; i<100; i++)" << std::endl;
      outfile << "  graycolors[i]=new TColor(1000+i, 1-(Float_t)i/100.,1-(Float_t)i/100.,1-(Float_t)i/100.);"<< std::endl;
   }
   if (CreateCanvas) 
      outfile<<"cMap = new TCanvas(\""<< fName <<"\",\"Cell Map for "<< fName <<"\",600,600);"<<std::endl;
   //
   outfile<<"TBox*a=new TBox();"<<std::endl;
   outfile<<"a->SetFillStyle(0);"<<std::endl;  // big frame
   outfile<<"a->SetLineWidth(4);"<<std::endl;
   //   outfile<<"a->SetLineColor(2);"<<std::endl;
   //   outfile<<"a->DrawBox("<<offs<<","<<offs<<","<<(offs+lpag)<<","<<(offs+lpag)<<");"<<std::endl;
   //
   outfile<<"TBox *b1=new TBox();"<<std::endl;  // single cell
   if (fillcells) {
      outfile << (colors ? "gStyle->SetPalette(1, 0);" : "gStyle->SetPalette(0);") <<std::endl;
      outfile <<"b1->SetFillStyle(1001);"<<std::endl;
      outfile<<"TBox *b2=new TBox();"<<std::endl;  // single cell
      outfile <<"b2->SetFillStyle(0);"<<std::endl;     
   }
   else {
      outfile <<"b1->SetFillStyle(0);"<<std::endl;
   }
   //

   Int_t lastcell = fLastCe;
   //   if (lastcell > 10000)
   //     lastcell = 10000;

   if (fillcells) 
      (colors ? gStyle->SetPalette(1, 0) : gStyle->SetPalette(0) );
   
   Double_t zmin = 1E8;  // minimal value (for color calculation)
   Double_t zmax = -1E8; // maximal value (for color calculation)

   Double_t value=0.;
   for (iCell=1; iCell<=lastcell; iCell++) {
      if ( fCells[iCell]->GetStat() == 1) {
         if (plotmean)
            value = GetCellMean(fCells[iCell]);
         else if (plotnevents)
            value = GetCellEntries(fCells[iCell]);
         else if (plotdensity)
            value = GetCellDensity(fCells[iCell]);
         else if (plotrms)
            value = GetCellRMS(fCells[iCell]);
         else if (plotrmsovmean)
            value = GetCellRMSovMean(fCells[iCell]);
         else if (plotdiscr) 
            value = GetCellDiscr(fCells[iCell]);
         else if (plotdiscrerr) 
            value = GetCellDiscrError(fCells[iCell]);
         else if (plotmonotarget) 
            value = GetCellRegValue0(fCells[iCell]); 
         else if (plotcellnumber) 
            value = iCell;
         if (value<zmin)
            zmin=value;
         if (value>zmax)
            zmax=value;
      }
   }
   outfile << "// observed minimum and maximum of distribution: " << std::endl;
   outfile << "// Double_t zmin = "<< zmin << ";" << std::endl;
   outfile << "// Double_t zmax = "<< zmax << ";" << std::endl;

   if (log_colors) {
      if (zmin<1)
         zmin=1;
      zmin=TMath::Log(zmin);
      zmax=TMath::Log(zmax);
      outfile << "// logarthmic color scale used " << std::endl;
   } else
      outfile << "// linear color scale used " << std::endl;

   outfile << "// used minimum and maximum of distribution (taking into account log scale if applicable): " << std::endl;
   outfile << "Double_t zmin = "<< zmin << ";" << std::endl;
   outfile << "Double_t zmax = "<< zmax << ";" << std::endl;

   // Next lines from THistPainter.cxx

   //   Int_t ndivz = colors ? abs(gStyle->GetNumberContours()) : 10;
   Int_t ncolors  = colors ? gStyle->GetNumberOfColors() : 100;
   Double_t dz = zmax - zmin;
   //   Double_t scale = ndivz/dz;
   Double_t scale = (ncolors-1)/dz;

   if (GetTotDim()==2) {
      PDEFoamVect  cellPosi(GetTotDim()); PDEFoamVect  cellSize(GetTotDim());
      outfile << "// =========== Rectangular cells  ==========="<< std::endl;
      for (iCell=1; iCell<=lastcell; iCell++) {
         if ( fCells[iCell]->GetStat() == 1) {
            fCells[iCell]->GetHcub(cellPosi,cellSize);
            x1 = offs+lpag*(cellPosi[0]);             y1 = offs+lpag*(cellPosi[1]);
            x2 = offs+lpag*(cellPosi[0]+cellSize[0]); y2 = offs+lpag*(cellPosi[1]+cellSize[1]);

            value = 0;
            if (fillcells) {
               if      (plotmean)       value = GetCellMean(fCells[iCell]);
               else if (plotnevents)    value = GetCellEntries(fCells[iCell]);
               else if (plotdensity)    value = GetCellDensity(fCells[iCell]);
               else if (plotrms)        value = GetCellRMS(fCells[iCell]);
               else if (plotrmsovmean)  value = GetCellRMSovMean(fCells[iCell]);
               else if (plotdiscr)      value = GetCellDiscr(fCells[iCell]);
               else if (plotdiscrerr)   value = GetCellDiscrError(fCells[iCell]);
               else if (plotmonotarget) value = GetCellRegValue0(fCells[iCell]); 
               else if (plotcellnumber) value = iCell;

               if (log_colors) {
                  if (value<1.) value=1;
                  value = TMath::Log(value);
               }

               Int_t color;
               if (colors)
                  color = gStyle->GetColorPalette(Int_t((value-zmin)*scale));
               else 
                  color = 1000+(Int_t((value-zmin)*scale));

               outfile << "b1->SetFillColor(" << color << ");" << std::endl;
            }

            //     cell rectangle
            outfile<<"b1->DrawBox("<<x1<<","<<y1<<","<<x2<<","<<y2<<");"<<std::endl;
            if (fillcells)
               outfile<<"b2->DrawBox("<<x1<<","<<y1<<","<<x2<<","<<y2<<");"<<std::endl;

            //     cell number
            if (lastcell<=250) {
               x = offs+lpag*(cellPosi[0]+0.5*cellSize[0]); y = offs+lpag*(cellPosi[1]+0.5*cellSize[1]);
            }
         }
      }
      outfile<<"// ============== End Rectangles ==========="<< std::endl;
   }//fDim=2
   //
   //
   outfile << "}" << std::endl;
   outfile.flush();
   outfile.close();
}

//________________________________________________________________________________________________
void TMVA::PDEFoam::SetVolumeFraction( Double_t vfr )
{ 
   // set VolFrac to internal foam density TFDISTR
   fDistr->SetVolumeFraction(vfr);
   SetPDEFoamVolumeFraction(vfr);
}

//________________________________________________________________________________________________
void TMVA::PDEFoam::FillBinarySearchTree( const Event* ev, EFoamType ft, Bool_t NoNegWeights )
{
   // Insert event to internal foam density TFDISTR.
   fDistr->FillBinarySearchTree(ev, ft, NoNegWeights);
}

//________________________________________________________________________________________________
void TMVA::PDEFoam::Create(Bool_t CreateCellElements)
{ 
   // Function that builds up the foam.
   SetRho(fDistr);      // give filled distribution (binary search tree) to Foam
   Initialize(CreateCellElements); // create foam cells from fDistr
}; 

//________________________________________________________________________________________________
void TMVA::PDEFoam::Init()
{ 
   // Initialize internal foam density TFDISTR
   fDistr->Initialize(GetTotDim());
}

//________________________________________________________________________________________________
void TMVA::PDEFoam::SetFoamType( EFoamType ft )
{
   // Set the foam type.  This determinates the method of the
   // calculation of the density during the foam build-up.
   if (ft==kDiscr)
      fDistr->SetDensityCalc(kDISCRIMINATOR);
   else if (ft==kMonoTarget)
      fDistr->SetDensityCalc(kTARGET);
   else
      fDistr->SetDensityCalc(kEVENT_DENSITY);
}

//________________________________________________________________________________________________
void TMVA::PDEFoam::PrintDensity(){
   // Information output
   fDistr->PrintDensity();
}
 
//________________________________________________________________________________________________
ostream& TMVA::operator<< ( ostream& os, const TMVA::PDEFoam& pdefoam )
{ 
   // Write PDEFoam variables to stream 'os'.
   pdefoam.PrintStream(os);
   return os; // Return the output stream.
}

//________________________________________________________________________________________________
istream& TMVA::operator>> ( istream& istr, TMVA::PDEFoam& pdefoam )
{ 
   // Read PDEFoam variables from stream 'istr'.
   pdefoam.ReadStream(istr);
   return istr;
}

//_______________________________________________________________________
void TMVA::PDEFoam::ReadStream( istream & istr )
{
   // Read PDEFoam variables from stream 'istr'.

   // inherited class variables: fLastCe, fNCells, fDim[GetTotDim()]
   istr >> fLastCe;
   istr >> fNCells;
   istr >> fDim;


   Double_t vfr = -1.;
   istr >> vfr;
   SetPDEFoamVolumeFraction(vfr);

   Log() << kVERBOSE << "Foam dimension: " << GetTotDim() << Endl;

   // read Class Variables: fXmin, fXmax
   if (fXmin) delete [] fXmin;
   if (fXmax) delete [] fXmax;
   fXmin = new Double_t[GetTotDim()];
   fXmax = new Double_t[GetTotDim()];
   for (Int_t i=0; i<GetTotDim(); i++) 
      istr >> fXmin[i];
   for (Int_t i=0; i<GetTotDim(); i++) 
      istr >> fXmax[i];
}

//_______________________________________________________________________
void TMVA::PDEFoam::PrintStream( ostream & ostr ) const
{
   // Write PDEFoam variables to stream 'os'.

   // inherited class variables: fLastCe, fNCells, fDim[GetTotDim()]
   ostr << fLastCe << std::endl;
   ostr << fNCells << std::endl;
   ostr << fDim    << std::endl;
   ostr << GetPDEFoamVolumeFraction() << std::endl;

   // write class variables: fXmin, fXmax
   for (Int_t i=0; i<GetTotDim(); i++) 
      ostr << fXmin[i] << std::endl;
   for (Int_t i=0; i<GetTotDim(); i++) 
      ostr << fXmax[i] << std::endl;
}

//_______________________________________________________________________
void TMVA::PDEFoam::AddXMLTo( void* parent ){
   // write foam variables to xml

   void *variables = gTools().xmlengine().NewChild( parent, 0, "Variables" );
   gTools().AddAttr( variables, "LastCe",           fLastCe );
   gTools().AddAttr( variables, "nCells",           fNCells );
   gTools().AddAttr( variables, "Dim",              fDim );
   gTools().AddAttr( variables, "VolumeFraction",   GetPDEFoamVolumeFraction() );

   void *xmin_wrap;
   for (Int_t i=0; i<GetTotDim(); i++){
      xmin_wrap = gTools().xmlengine().NewChild( variables, 0, "Xmin" );
      gTools().AddAttr( xmin_wrap, "Index", i );
      gTools().AddAttr( xmin_wrap, "Value", fXmin[i] );
   }

   void *xmax_wrap;
   for (Int_t i=0; i<GetTotDim(); i++){
      xmax_wrap = gTools().xmlengine().NewChild( variables, 0, "Xmax" );
      gTools().AddAttr( xmax_wrap, "Index", i );
      gTools().AddAttr( xmax_wrap, "Value", fXmax[i] );
   }
}

//_______________________________________________________________________
void TMVA::PDEFoam::ReadXML( void* parent ){
   void *variables = gTools().xmlengine().GetChild( parent );
   gTools().ReadAttr( variables, "LastCe",         fLastCe );
   gTools().ReadAttr( variables, "nCells",         fNCells );
   gTools().ReadAttr( variables, "Dim",            fDim );
   Float_t volfr;
   gTools().ReadAttr( variables, "VolumeFraction", volfr );
   SetPDEFoamVolumeFraction( volfr );

   if (fXmin) delete [] fXmin;
   if (fXmax) delete [] fXmax;
   fXmin = new Double_t[GetTotDim()];
   fXmax = new Double_t[GetTotDim()];

   void *xmin_wrap = gTools().xmlengine().GetChild( variables );
   for (Int_t counter=0; counter<fDim; counter++) {
      Int_t i=0;
      gTools().ReadAttr( xmin_wrap , "Index", i );
      if (i >= GetTotDim() || i<0)
	 Log() << kFATAL << "dimension index out of range:" << i << Endl;
      gTools().ReadAttr( xmin_wrap , "Value", fXmin[i] );
      xmin_wrap = gTools().xmlengine().GetNext( xmin_wrap );
   }

   void *xmax_wrap = xmin_wrap; //gTools().xmlengine().GetChild( variables );
   for (Int_t counter=0; counter<fDim; counter++) {
      Int_t i=0;
      gTools().ReadAttr( xmax_wrap , "Index", i );
      if (i >= GetTotDim() || i<0)
	 Log() << kFATAL << "dimension index out of range:" << i << Endl;
      gTools().ReadAttr( xmax_wrap , "Value", fXmax[i] );
      xmax_wrap = gTools().xmlengine().GetNext( xmax_wrap );
   }
}

////////////////////////////////////////////////////////////////////////////////
//       End of Class PDEFoam                                                   //
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
//       Begin of Class TFDISTR                                               //
////////////////////////////////////////////////////////////////////////////////

/**********************************************************************************
 * Project: TMVA - a Root-integrated toolkit for multivariate data analysis       *
 * Package: TMVA                                                                  *
 * Class  : TMVA::DTFISTR                                                         *
 * Web    : http://tmva.sourceforge.net                                           *
 *                                                                                *
 * Description:                                                                   *
 *      Helper class used by the PDEFoam object to evaluate the event density       *
 *      at a given point in the Foam.  The main Function is TFDISTR::Density().   *
 *                                                                                *
 * Authors (alphabetical):                                                        *
 *      Tancredi Carli                                                            *
 *      Dominik Dannheim                                                          *
 *      Alexander Voigt                                                           *
 *                                                                                *
 * Copyright (c) 2005:                                                            *
 *      CERN, Switzerland                                                         *
 *                                                                                *
 * Redistribution and use in source and binary forms, with or without             *
 * modification, are permitted according to the terms listed in LICENSE           *
 * (http://mva.sourceforge.net/license.txt)                                       *
 *                                                                                *
 **********************************************************************************/

//_______________________________________________________________________
//
// Implementation of TFDISTR
//
// The TFDSITR class provides an interface between the Binary search tree
// and the PDEFoam object.  In order to build-up the foam one needs to 
// calculate the density of events at a given point (sampling during
// Foam build-up).  The function TFDISTR::Density() does this job.  It
// Uses a binary search tree, filled with training events, in order to
// provide this density.
//_______________________________________________________________________




//________________________________________________________________________________________________
TMVA::TFDISTR::TFDISTR() :
   fDim(-1),
   fXmin(0),
   fXmax(0),
   fVolFrac(-1.),
   fBst(NULL),
   fDensityCalc(kEVENT_DENSITY), // default: fill event density to BinarySearchTree
   fSignalClass(1),
   fBackgroundClass(0),
   fLogger( new MsgLogger("TFDISTR"))
{}

//________________________________________________________________________________________________
TMVA::TFDISTR::~TFDISTR() {
   if (fBst)  delete fBst;
   if (fXmin) delete [] fXmin;  fXmin=0;
   if (fXmax) delete [] fXmax;  fXmax=0;
   delete fLogger;
}


//________________________________________________________________________________________________
void TMVA::TFDISTR::PrintDensity()
{
   // Information output about foam density

   char name[]={"EventfromDensity::PrintDensity"};

   Log() << kINFO << name<<" Volume fraction to search for events: "<<fVolFrac<< Endl;
   Log() << kINFO << name<<" Binary Tree: "<<fBst<< Endl;

   if (!fBst) Log() << kINFO <<name<<" Binary tree not found ! "<< Endl;

   Log() << kINFO <<name<<" Volfraction= "<<fVolFrac<< Endl;

   for (Int_t idim=0; idim<fDim; idim++){
      Log() << kINFO <<name<<idim<<" fXmin["<<idim<<"]= "<<fXmin[idim]
              <<" fXmax["<<idim<<"]= "<<fXmax[idim]<< Endl;
   }
}

//________________________________________________________________________________________________
void TMVA::TFDISTR::Initialize( Int_t ndim )
{
   // Initialisation procedure of internal foam density.
   // Set dimension to 'ndim' and create BinarySearchTree.

   std::string name = "EventfromDensity::PreInitialize:";
   this->SetDim(ndim);

   if (fBst) delete fBst;
   fBst = new TMVA::BinarySearchTree();
  
   if (!fBst){
      Log() << kFATAL << name << "ERROR: an not create binary tree !" << Endl;
      return;
   }
  
   fBst->SetPeriode(fDim);
}

//________________________________________________________________________________________________
void TMVA::TFDISTR::FillBinarySearchTree( const Event* ev, EFoamType ft, Bool_t NoNegWeights )
{
   // This method creates an TMVA::Event and inserts it into the
   // binary search tree.
   //
   // If 'NoNegWeights' is true, an event with negative weight will
   // not be filled into the foam.  (Default value: false)

   if(NoNegWeights && ev->GetWeight()<=0)
      return;

   TMVA::Event *event = new TMVA::Event(*ev);
   event->SetSignalClass( fSignalClass );

   // set event class and normalization
   if (ft==kSeparate || ft==kDiscr){
      event->SetClass(ev->IsSignal() ? fSignalClass : fBackgroundClass);
   } else if (ft==kMultiTarget){
      // since in multi target regression targets are handled like
      // variables, remove targets and add them to the event variabels
      std::vector<Float_t> targets = ev->GetTargets();
      for (UInt_t i = 0; i < targets.size(); i++)
	 event->SetVal(i+ev->GetValues().size(), targets.at(i));
      event->GetTargets().clear();
      event->SetClass(fSignalClass);
   }
   fBst->Insert(event);
}

//________________________________________________________________________________________________
void TMVA::TFDISTR::FillEdgeHist( Int_t nDim, TObjArray *myfHistEdg, 
                                  Double_t *cellPosi, Double_t *cellSize, Double_t *ceSum, Double_t ceVol ) 
{
   // New method to fill edge histograms directly, without MC sampling.
   // DD 10.Jan.2008

   Double_t wt;
   std::vector<Double_t> lb(nDim+1);
   std::vector<Double_t> ub(nDim+1);
   Double_t *valuesarr = new Double_t[Int_t(nDim)];
  
   for (Int_t idim=0; idim<nDim; idim++){
      lb[idim]=fXmin[idim]+(fXmax[idim]-fXmin[idim])*cellPosi[idim];
      ub[idim]=fXmin[idim]+(fXmax[idim]-fXmin[idim])*(cellPosi[idim]+cellSize[idim]);
   }
   lb[nDim] = -1.e19;
   ub[nDim] = +1.e19;

   TMVA::Volume volume(&lb, &ub);
   std::vector<const TMVA::BinarySearchTreeNode*> nodes;
   if (!fBst) {
      Log() << kFATAL <<"Binary tree not found ! "<< Endl; 
      exit (1);
   }
   fBst->SearchVolume(&volume, &nodes);
   for (std::vector<const TMVA::BinarySearchTreeNode*>::iterator inode = nodes.begin(); inode != nodes.end(); inode++) {
      const std::vector<Float_t>& values = (*inode)->GetEventV();
      for (Int_t idim=0; idim<nDim; idim++) {
         valuesarr[idim]=(values[idim]-fXmin[idim])/(fXmax[idim]-fXmin[idim]);
      }
      Double_t event_density = 0;
      wt = (TFDISTR::Density(nDim, valuesarr, event_density)) * ceVol;
      for (Int_t idim=0; idim<nDim; idim++) 
         ((TH1D *)(*myfHistEdg)[idim])->Fill((values[idim]-fXmin[idim])/(fXmax[idim]-fXmin[idim]), wt);
      ceSum[0] += wt;    // sum of weights
      ceSum[1] += wt*wt; // sum of weights squared
      ceSum[2]++;        // sum of 1
      if (ceSum[3]>wt) ceSum[3]=wt;  // minimum weight;
      if (ceSum[4]<wt) ceSum[4]=wt;  // maximum weight
   }

   delete[] valuesarr;
}

//________________________________________________________________________________________________
UInt_t TMVA::TFDISTR::GetNEvents( PDEFoamCell* cell )
{
   // Return number of events (from binary search tree) within a certain volume given 
   // by the cell coordinates and size.

   PDEFoamVect  cellSize(fDim);
   PDEFoamVect  cellPosi(fDim);

   cell->GetHcub(cellPosi,cellSize);

   std::vector<Float_t> lb;
   std::vector<Float_t> ub;

   for (Int_t idim=0; idim<fDim; idim++) {
      lb.push_back(VarTransformInvers(idim, cellPosi[idim]));
      ub.push_back(VarTransformInvers(idim, cellPosi[idim] + cellSize[idim]));
   }

   TMVA::Volume volume(&lb, &ub);
   std::vector<const TMVA::BinarySearchTreeNode*> nodes;

   if (!fBst) {
      Log() << kFATAL << "<TFDISTR::GetNEvents> Binary tree not found!" << Endl; 
      exit (1);
   }

   fBst->SearchVolume(&volume, &nodes);
   return nodes.size();
}

//________________________________________________________________________________________________
Bool_t TMVA::TFDISTR::CellRMSCut( PDEFoamCell* cell, Float_t rms_cut, Int_t nbin )
{
   // Checks whether the RMS within the cell is greater than 'rms_cut'.
   // Furthermore control whether RMSError < RMS.
   //
   // 1) fill histograms for each dimension
   // 2) check whether RMS/mean > RMS_error/mean in each dimension
   // 3) if 2) is kTRUE -> return kTRUE only if RMS/mean > rms_cut in one dimension
   //    --> cell may be splitten

   // get cell coordinates
   PDEFoamVect  cellSize(fDim);
   PDEFoamVect  cellPosi(fDim);

   cell->GetHcub(cellPosi, cellSize);

   std::vector<Float_t> lb;
   std::vector<Float_t> ub;

   for (Int_t idim=0; idim<fDim; idim++) {
      lb.push_back(VarTransformInvers(idim, cellPosi[idim]));
      ub.push_back(VarTransformInvers(idim, cellPosi[idim] + cellSize[idim]));
   }

   TMVA::Volume volume(&lb, &ub);
   std::vector<const TMVA::BinarySearchTreeNode*> nodes;

   if (!fBst) {
      Log() << kFATAL << "<TFDISTR::CellRMSCut> Binary tree not found!" << Endl; 
      return 0.;
   }

   fBst->SearchVolume(&volume, &nodes);

   // if no events found -> do not split cell
   if (nodes.size() <= 1)
      return kFALSE;

   // create histogram for each dimension
   std::vector<TH1F*> histo;
   for (Int_t i=0; i<fDim; i++){
      std::stringstream title (std::stringstream::in | std::stringstream::out);
      title << "proj" << i;
      histo.push_back(new TH1F(title.str().c_str(), title.str().c_str(), nbin, lb.at(i), ub.at(i)));
   }

   // 1) fill histos with all events found
   for (UInt_t i=0; i<nodes.size(); i++){
      for (Int_t d=0; d<fDim; d++)
         (histo.at(d))->Fill((nodes.at(i)->GetEventV()).at(d), nodes.at(i)->GetWeight());
   }

   // calc RMS/mean and RMSError/mean
   std::vector<Float_t> rms_mean, rms_err_mean;
   for (Int_t i=0; i<fDim; i++){ // loop over all histograms

      // loop over all bins in histo
      std::vector<Float_t> bin_val;
      for (Int_t k=1; k<=nbin; k++){
         bin_val.push_back( histo.at(i)->GetBinContent(k) );
      }

      // calc mean
      Float_t mean = 0;
      for (UInt_t k=0; k<bin_val.size(); k++)
         mean += bin_val.at(k);
      mean /= bin_val.size();

      // calc rms
      Float_t rms  = 0;
      for (UInt_t k=0; k<bin_val.size(); k++)
         rms += TMath::Power( bin_val.at(k) - mean, 2 );	 
      rms /= (bin_val.size()-1);  // variance
      rms = TMath::Sqrt(rms)/mean; // significan value

      // calc error on rms
      Float_t rms_err = 0;
      rms_err = (1+rms*TMath::Sqrt(2))*rms/TMath::Sqrt(2*bin_val.size());

      // save values
      if (TMath::Abs(mean) > 1.0e-15){
         rms_mean.push_back( rms );
         rms_err_mean.push_back( rms_err );
      }
      else {
         rms_mean.push_back(0.);     // set values to avoid cut-check
         rms_err_mean.push_back(1.);
      }
   }

   // 2) and 3) apply cut on 'rms_cur'
   Bool_t result = kFALSE;
   for (Int_t i=0; i<fDim; i++){
      //if (rms_mean.at(i) > rms_err_mean.at(i))  // if enough statistics
      result = result || (rms_mean.at(i) > rms_cut);
   }

   // delete histograms
   for (Int_t i=0; i<fDim; i++)
      delete histo.at(i);

   return result;
}

//________________________________________________________________________________________________
Double_t TMVA::TFDISTR::Density( Int_t nDim, Double_t *Xarg, Double_t &event_density )
{
   // This function is needed during the foam buildup.
   // It return a certain density depending on the selected classification
   // or regression options:
   //
   // In case of separated foams (classification) or multi target regression:
   //  - returns event density within volume (specified by VolFrac)
   // In case of unified foams: (classification)
   //  - returns discriminator (N_sig)/(N_sig + N_bg) divided by volume (specified by VolFrac)
   // In case of mono target regression:
   //  - returns average target value within volume divided by volume (specified by VolFrac)

   assert(nDim == fDim);

   Bool_t simplesearch=true; // constant volume for all searches
   Bool_t usegauss=true;     // kFALSE: use Teepee function, kTRUE: use Gauss with sigma=0.3
   Int_t targetevents=0;     // if >0: density is defined as inverse of volume that includes targetevents
   //                           (this option should probably not be used together simplesearch=false) 
   char name[]={" DensityFromEvents: "};
   Bool_t debug0 = false;
   Bool_t debug  = false;

   Double_t volscale=1.;
   Double_t lasthighvolscale=0.;
   Double_t lastlowvolscale=0.;
   Int_t nit=0;

   // probevolume relative to hypercube with edge length 1:
   Double_t probevolume_inv;

   static Int_t nev=0;  nev++;

   if (debug) for (Int_t idim=0; idim<nDim; idim++) 
                 Log() << kVERBOSE << nev << name << idim <<" unscaled in: Xarg= "<< Xarg[idim] << Endl;   

   //make a variable transform, since Foam only knows about x=[0,1]
   Double_t wbin;
   for (Int_t idim=0; idim<nDim; idim++){
      if (debug)
         std::cerr << "fXmin[" << idim << "] = " << fXmin[idim]
                   << ", fXmax[" << idim << "] = " << fXmax[idim] << std::endl;
      wbin=fXmax[idim]-fXmin[idim];
      Xarg[idim]=fXmin[idim]+wbin*Xarg[idim];
   }

   if (debug0) for (Int_t idim=0; idim<nDim; idim++) 
                  Log() << kVERBOSE <<nev<<name<<idim<<" scaled in: Xarg= "<<Xarg[idim]<< Endl;

   //create volume around point to be found
   std::vector<Double_t> lb(nDim);
   std::vector<Double_t> ub(nDim);

 volumesearchstart:
   probevolume_inv = pow((fVolFrac/2/volscale), nDim); 

   for (Int_t idim = 0; idim < fDim; idim++) {
      lb[idim] = Xarg[idim];
      ub[idim] = Xarg[idim];
   }

   for (Int_t idim = 0; idim < nDim; idim++) {
      Double_t volsize=(fXmax[idim] - fXmin[idim]) / fVolFrac * volscale;    
      lb[idim] -= volsize;
      ub[idim] += volsize;
      if (debug) {
         std::cerr << "lb[" << idim << "]=" << lb[idim] << std::endl;
         std::cerr << "ub[" << idim << "]=" << ub[idim] << std::endl;
      }
   }

   TMVA::Volume volume(&lb, &ub);
      
   std::vector<const TMVA::BinarySearchTreeNode*> nodes;

   if (!fBst) {
      Log() << kFATAL <<name<<" Binary tree not found ! "<< Endl; 
   }

   // do range searching
   fBst->SearchVolume(&volume, &nodes);

   // normalized density: (number of counted events) / volume / (total number of events)
   // should be ~1 on average
   Double_t count=(Double_t) (nodes.size()); // number of events found

   event_density = count * probevolume_inv;  // store density based on total number of events   

   // add a small number, to stabilize cell-division algorithm

   if (targetevents>0 && nit<25) {
      nit++;
      if (count<targetevents) {   // repeat search with increased volume if not enough events found
         lastlowvolscale=volscale;
         if (lasthighvolscale>0.)
            volscale+=(lasthighvolscale-volscale)/2;
         else
            volscale*=1.5;
         goto volumesearchstart;
      }
      //      else if (count>targetevents) { // repeat search with decreased volume if too many events found
      //         lasthighvolscale=volscale;
      //         if (lastlowvolscale>0.)
      //            volscale-=(volscale-lastlowvolscale)/2;
      //         else
      //            volscale*=0.5;
      //         goto volumesearchstart;
      //      }
   }

   if (targetevents>0 && count<targetevents)
      Log() << kWARNING << "WARNING: Number of target events not reached within 25 iterations. count==" 
              << count << Endl;

   Double_t N_sig = 0;
   Double_t N_tar = 0;
   Double_t weighted_count = 0.; // number of events found (sum of weights!)
   for (UInt_t j=0; j<nodes.size(); j++)
      weighted_count += (nodes.at(j))->GetWeight();

   if (FillDiscriminator()){ // calc number of signal events in nodes
      N_sig = 0;
      // sum over all nodes->IsSignal;
      for (Int_t j=0; j<count; j++){
         N_sig += ((nodes.at(j))->IsSignal()?1.:0.) * (nodes.at(j))->GetWeight();
      }
   }
   else if (FillTarget0()){
      N_tar = 0;
      // sum over all nodes->GetTarget(0);
      for (Int_t j=0; j<count; j++) {
         if (((nodes.at(j))->GetTargets()).size() < 1) 
            Log() << kFATAL << "ERROR: No targets for node " << j << Endl;
         N_tar += ((nodes.at(j))->GetTargets()).at(0) * ((nodes.at(j))->GetWeight());
      }
   }

   if (simplesearch){
      if (FillDiscriminator())
         return (N_sig/(weighted_count+0.1))*probevolume_inv; // fill:  (N_sig/N_total) / (cell_volume)
      else if (FillTarget0())
         return (N_tar/(weighted_count+0.1))*probevolume_inv; // fill:  (N_tar/N_total) / (cell_volume)
      else
         return ((weighted_count+0.1)*probevolume_inv); // fill:  N_total(weighted) / cell_volume
   }
  
   Double_t density = 0.;
   Double_t normalised_distance = 0;

   if (count==0)
      return (0.1*probevolume_inv);

   unsigned usednodes;

   for (usednodes = 0; usednodes < nodes.size(); usednodes++) { // loop over all nodes
      const std::vector<Float_t>& values = nodes[usednodes]->GetEventV();
      for (Int_t idim = 0; idim < nDim; idim++) 
         normalised_distance += pow( ( values[idim]-Xarg[idim] )/ (ub[idim]-lb[idim]) * 2 , 2);
      normalised_distance = sqrt(normalised_distance/nDim);
      if (usegauss)
         density+=TMath::Gaus(normalised_distance, 0, 0.3, kFALSE);    // Gaus Kernel with sigma=0.3
      else  
         density+=(1-normalised_distance);  // Teepee kernel
   }
   density /= usednodes;

   if (FillDiscriminator())
      density = (N_sig/density)*probevolume_inv; // fill:  (N_sig/N_total) / (cell_volume)
   else if (FillTarget0())
      density = (N_tar/density)*probevolume_inv; // fill:  (N_tar/N_total) / (cell_volume)
   else 
      density *= probevolume_inv; // fill:  N_total / cell_volume

   return density;
}

//________________________________________________________________________________________________
TH2D* TMVA::TFDISTR::MakeHistogram( Int_t nbinsx, Int_t nbinsy ) 
{
   // Unused function.
   // Warning: only works in 2D for now.

   //  const Bool_t debug = kTRUE;
   const Bool_t debug = kFALSE;

   TH2D *foamhist = new TH2D("foamhist", "Distributon",
                             nbinsx, fXmin[0], fXmax[0],
                             nbinsy, fXmin[1], fXmax[1]);
   if (debug)
      std::cerr << "TFDIST::MakeHistogram, nbinsx=" << nbinsx
                << ", nbinsy=" << nbinsy
                << ", fXmin[0]=" << fXmin[0]
                << ", fXmax[0]=" << fXmax[0]
                << ", fXmin[1]=" << fXmin[1]
                << ", fXmax[1]=" << fXmax[1]
                << std::endl;

   Double_t xvec[2];

   for (Int_t i = 1; i < nbinsx+1; i++) { // ROOT's weird bin numbering
      for (Int_t j = 1; j < nbinsy+1; j++) {
         xvec[0] = foamhist->GetXaxis()->GetBinCenter(i);
         xvec[1] = foamhist->GetYaxis()->GetBinCenter(j);

         // Transform to foam-internal coordinate space, that this->Density expects
         xvec[0] = (xvec[0] - fXmin[0]) / (fXmax[0] - fXmin[0]);
         xvec[1] = (xvec[1] - fXmin[1]) / (fXmax[1] - fXmin[1]);

         // Note: this->Density changes xvec, need to print them before!
         if (debug)
            std::cerr << "xvec[0]=" << xvec[0]
                      << ", xvec[1]=" << xvec[1]
                      << std::endl;

         Int_t ibin = foamhist->GetBin(i, j);
         Double_t var = this->Density(2, xvec);

         foamhist->SetBinContent(ibin, var);

         if (debug)
            std::cerr << "i=" << i
                      << ", j=" << j
                      << ", var=" << var
                      << ", ibin=" << ibin
                      << std::endl;
      }
   }

   return foamhist;
}

ClassImp(TMVA::TFDISTR)

////////////////////////////////////////////////////////////////////////////////
//       End of Class TFDISTR                                                 //
////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////
//                                                          //
// Class PDEFoamIntegrand is an Abstract class representing   //
// n-dimensional real positive integrand function           //
//                                                          //
//////////////////////////////////////////////////////////////

ClassImp(TMVA::PDEFoamIntegrand);

TMVA::PDEFoamIntegrand::PDEFoamIntegrand(){};


////////////////////////////////////////////////////////////////////////////////////
//                                                                                //
// Class PDEFoamCell  used in PDEFoam                                             //
// ==================================                                             //
// Objects of this class are hyper-rectangular cells organized in the binary tree.//
// Special algorithm for encoding relative positioning of the cells               //
// allow to save total memory allocation needed for the system of cells.          //
//                                                                                //
////////////////////////////////////////////////////////////////////////////////////

ClassImp(TMVA::PDEFoamCell)

//________________________________________________________________________________
TMVA::PDEFoamCell::PDEFoamCell()
{
   // Default constructor for streamer

   fParent  = 0;
   fDaught0 = 0;
   fDaught1 = 0;
   fElement = 0;
}

//_________________________________________________________________________________
TMVA::PDEFoamCell::PDEFoamCell(Int_t kDim)
{
   // User constructor allocating single empty Cell
   if (  kDim >0) {
      //---------=========----------
      fDim     = kDim;
      fStatus   = 1;
      fParent   = 0;
      fDaught0  = 0;
      fDaught1  = 0;
      fXdiv     = 0.0;
      fBest     = 0;
      fVolume   = 0.0;
      fIntegral = 0.0;
      fDrive    = 0.0;
      fPrimary  = 0.0;
      fElement  = 0;
   } else
      Error( "PDEFoamCell", "Dimension has to be >0" );
}

//_________________________________________________________________________________
TMVA::PDEFoamCell::PDEFoamCell(PDEFoamCell &From): TObject(From)
{
   // Copy constructor (not tested!)

   Error( "PDEFoamCell", "+++++ NEVER USE Copy constructor for PDEFoamCell");
   fStatus      = From.fStatus;
   fParent      = From.fParent;
   fDaught0     = From.fDaught0;
   fDaught1     = From.fDaught1;
   fXdiv        = From.fXdiv;
   fBest        = From.fBest;
   fVolume      = From.fVolume;
   fIntegral    = From.fIntegral;
   fDrive       = From.fDrive;
   fPrimary     = From.fPrimary;
   fElement     = From.fElement;
}

//___________________________________________________________________________________
TMVA::PDEFoamCell::~PDEFoamCell()
{
   // Destructor
}

//___________________________________________________________________________________
TMVA::PDEFoamCell& TMVA::PDEFoamCell::operator=(const PDEFoamCell &From)
{
   // Substitution operator = (never used)

   Info("PDEFoamCell", "operator=\n ");
   if (&From == this) return *this;
   fStatus      = From.fStatus;
   fParent      = From.fParent;
   fDaught0     = From.fDaught0;
   fDaught1     = From.fDaught1;
   fXdiv        = From.fXdiv;
   fBest        = From.fBest;
   fVolume      = From.fVolume;
   fIntegral    = From.fIntegral;
   fDrive       = From.fDrive;
   fPrimary     = From.fPrimary;
   fElement     = From.fElement;
   return *this;
}


//___________________________________________________________________________________
void TMVA::PDEFoamCell::Fill(Int_t Status, PDEFoamCell *Parent, PDEFoamCell *Daugh1, PDEFoamCell *Daugh2)
{
   // Fills in certain data into newly allocated cell

   fStatus  = Status;
   fParent  = Parent;
   //   Log() << "D1" << Daugh1 << Endl;
   fDaught0 = Daugh1;
   fDaught1 = Daugh2;
}

////////////////////////////////////////////////////////////////////////////////
//              GETTERS/SETTERS
////////////////////////////////////////////////////////////////////////////////

//_____________________________________________________________________________________
void    TMVA::PDEFoamCell::GetHcub( PDEFoamVect &cellPosi, PDEFoamVect &cellSize)  const
{
   // Provides size and position of the cell
   // These parameter are calculated by analyzing information in all parents
   // cells up to the root cell. It takes time but saves memory.
   if(fDim<1) return;
   const PDEFoamCell *pCell,*dCell;
   cellPosi = 0.0; cellSize=1.0; // load all components
   dCell = this;
   while(dCell != 0) {
      pCell = dCell->GetPare();
      if( pCell== 0) break;
      Int_t    kDiv = pCell->fBest;
      Double_t xDivi = pCell->fXdiv;
      if(dCell == pCell->GetDau0()  ) {
         cellSize[kDiv] *=xDivi;
         cellPosi[kDiv] *=xDivi;
      } else if(   dCell == pCell->GetDau1()  ) {
         cellSize[kDiv] *=(1.0-xDivi);
         cellPosi[kDiv]  =cellPosi[kDiv]*(1.0-xDivi)+xDivi;
      } else {
         Error( "GetHcub ","Something wrong with linked tree \n");
      }
      dCell=pCell;
   }//while
}//GetHcub

//______________________________________________________________________________________
void    TMVA::PDEFoamCell::GetHSize( PDEFoamVect &cellSize)  const
{
   // Provides size of the cell
   // Size parameters are calculated by analyzing information in all parents
   // cells up to the root cell. It takes time but saves memory.
   if(fDim<1) return;
   const PDEFoamCell *pCell,*dCell;
   cellSize=1.0; // load all components
   dCell = this;
   while(dCell != 0) {
      pCell = dCell->GetPare();
      if( pCell== 0) break;
      Int_t    kDiv = pCell->fBest;
      Double_t xDivi = pCell->fXdiv;
      if(dCell == pCell->GetDau0() ) {
         cellSize[kDiv]=cellSize[kDiv]*xDivi;
      } else if(dCell == pCell->GetDau1()  ) {
         cellSize[kDiv]=cellSize[kDiv]*(1.0-xDivi);
      } else {
         Error( "GetHSize ","Something wrong with linked tree \n");
      }
      dCell=pCell;
   }//while
}//GetHSize

//_________________________________________________________________________________________
void TMVA::PDEFoamCell::CalcVolume(void)
{
   // Calculates volume of the cell using size params which are calculated

   Int_t k;
   Double_t volu=1.0;
   if(fDim>0) {         // h-cubical subspace
      PDEFoamVect cellSize(fDim);
      GetHSize(cellSize);
      for(k=0; k<fDim; k++) volu *= cellSize[k];
   }
   fVolume =volu;
}

//__________________________________________________________________________________________
void TMVA::PDEFoamCell::Print(Option_t *option) const
{
   // Printout of the cell geometry parameters for the debug purpose

   if (!option) Error( "Print", "No option set\n");

   cout <<  " Status= "<<     fStatus   <<",";
   cout <<  " Volume= "<<     fVolume   <<",";
   cout <<  " TrueInteg= " << fIntegral <<",";
   cout <<  " DriveInteg= "<< fDrive    <<",";
   cout <<  " PrimInteg= " << fPrimary  <<",";
   cout << endl;
   cout <<  " Xdiv= "<<fXdiv<<",";
   cout <<  " Best= "<<fBest<<",";
   cout <<  " Parent=  {"<< (GetPare() ? GetPare()->GetSerial() : -1) <<"} "; // extra DEBUG
   cout <<  " Daught0= {"<< (GetDau0() ? GetDau0()->GetSerial() : -1 )<<"} "; // extra DEBUG
   cout <<  " Daught1= {"<< (GetDau1() ? GetDau1()->GetSerial()  : -1 )<<"} "; // extra DEBUG
   cout << endl;
   //
   //
   if (fDim>0 ) {
      PDEFoamVect cellPosi(fDim); PDEFoamVect cellSize(fDim);
      GetHcub(cellPosi,cellSize);
      cout <<"   Posi= "; cellPosi.Print("1"); cout<<","<< endl;
      cout <<"   Size= "; cellSize.Print("1"); cout<<","<< endl;
   }
}
///////////////////////////////////////////////////////////////////
//        End of  class  PDEFoamCell                             //
///////////////////////////////////////////////////////////////////



///////////////////////////////////////////////////////////////////////////////////
//                                                                               //
// Class  PDEFoamMaxwt                                                           //
// ===================                                                           //
// Small auxiliary class for controlling MC weight.                              //
// It provides certain measure of the "maximum weight"                           //
// depending on small user-parameter "epsilon".                                  //
// It creates and uses 2 histograms of the TH1D class.                           //
// User defines no. of bins nBin,  nBin=1000 is  recommended                     //
// wmax defines weight range (1,wmax), it is adjusted "manually"                 //
//                                                                               //
///////////////////////////////////////////////////////////////////////////////////

ClassImp(TMVA::PDEFoamMaxwt);

//____________________________________________________________________________
TMVA::PDEFoamMaxwt::PDEFoamMaxwt():
   fLogger( new MsgLogger("PDEFoamMaxwt") )
{
   // Constructor for streamer
   fNent = 0;
   fnBin = 0;
   fWtHst1 = 0;
   fWtHst2 = 0;
}

//____________________________________________________________________________
TMVA::PDEFoamMaxwt::PDEFoamMaxwt(Double_t wmax, Int_t nBin):
   fLogger( new MsgLogger("PDEFoamMaxwt") )
{
   // Principal user constructor
   fNent = 0;
   fnBin = nBin;
   fwmax = wmax;
   fWtHst1 = new TH1D("PDEFoamMaxwt_hst_Wt1","Histo of weight   ",nBin,0.0,wmax);
   fWtHst2 = new TH1D("PDEFoamMaxwt_hst_Wt2","Histo of weight**2",nBin,0.0,wmax);
   fWtHst1->SetDirectory(0);// exclude from diskfile
   fWtHst2->SetDirectory(0);// and enable deleting
}

//______________________________________________________________________________
TMVA::PDEFoamMaxwt::PDEFoamMaxwt(PDEFoamMaxwt &From): 
   TObject(From),
   fLogger( new MsgLogger("PDEFoamMaxwt") )
{
   // Explicit COPY CONSTRUCTOR (unused, so far)
   fnBin   = From.fnBin;
   fwmax   = From.fwmax;
   fWtHst1 = From.fWtHst1;
   fWtHst2 = From.fWtHst2;
   Error( "PDEFoamMaxwt","COPY CONSTRUCTOR NOT TESTED!");
}

//_______________________________________________________________________________
TMVA::PDEFoamMaxwt::~PDEFoamMaxwt()
{
   // Destructor
   delete fWtHst1; // For this SetDirectory(0) is needed!
   delete fWtHst2; //
   fWtHst1=0;
   fWtHst2=0;
   delete fLogger;
}
//_______________________________________________________________________________
void TMVA::PDEFoamMaxwt::Reset()
{
   // Reseting weight analysis
   fNent = 0;
   fWtHst1->Reset();
   fWtHst2->Reset();
}

//_______________________________________________________________________________
TMVA::PDEFoamMaxwt& TMVA::PDEFoamMaxwt::operator=(const PDEFoamMaxwt &From)
{
   // substitution =
   if (&From == this) return *this;
   fnBin = From.fnBin;
   fwmax = From.fwmax;
   fWtHst1 = From.fWtHst1;
   fWtHst2 = From.fWtHst2;
   return *this;
}

//________________________________________________________________________________
void TMVA::PDEFoamMaxwt::Fill(Double_t wt)
{
   // Filling analyzed weight
   fNent =  fNent+1.0;
   fWtHst1->Fill(wt,1.0);
   fWtHst2->Fill(wt,wt);
}

//________________________________________________________________________________
void TMVA::PDEFoamMaxwt::Make(Double_t eps, Double_t &MCeff)
{
   // Calculates Efficiency= aveWt/wtLim for a given tolerance level epsilon<<1
   // To be called at the end of the MC run.

   Double_t wtLim,aveWt;
   GetMCeff(eps, MCeff, wtLim);
   aveWt = MCeff*wtLim;
   Log()<< "00000000000000000000000000000000000000000000000000000000000000000000000"<<Endl;
   Log()<< "00 -->wtLim: No_evt ="<<fNent<<"   <Wt> = "<<aveWt<<"  wtLim=  "<<wtLim<<Endl;
   Log()<< "00 -->wtLim: For eps = "<<eps  <<"    EFFICIENCY <Wt>/wtLim= "<<MCeff<<Endl;
   Log()<< "00000000000000000000000000000000000000000000000000000000000000000000000"<<Endl;
}

//_________________________________________________________________________________
void TMVA::PDEFoamMaxwt::GetMCeff(Double_t eps, Double_t &MCeff, Double_t &wtLim)
{
   // Calculates Efficiency= aveWt/wtLim for a given tolerance level epsilon<<1
   // using information stored in two histograms.
   // To be called at the end of the MC run.

   Int_t ib,ibX;
   Double_t lowEdge,bin,bin1;
   Double_t aveWt, aveWt1;

   fWtHst1->Print();
   fWtHst2->Print();

   // Convention on bin-numbering: nb=1 for 1-st bin, underflow nb=0, overflow nb=Nb+1
   Double_t sum   = 0.0;
   Double_t sumWt = 0.0;
   for(ib=0;ib<=fnBin+1;ib++) {
      sum   += fWtHst1->GetBinContent(ib);
      sumWt += fWtHst2->GetBinContent(ib);
   }
   if( (sum == 0.0) || (sumWt == 0.0) ) {
      Log()<<"PDEFoamMaxwt::Make: zero content of histogram !!!,sum,sumWt ="<<sum<<sumWt<<Endl;
   }
   aveWt = sumWt/sum;
   //--------------------------------------
   for( ibX=fnBin+1; ibX>0; ibX--) {
      lowEdge = (ibX-1.0)*fwmax/fnBin;
      sum   = 0.0;
      sumWt = 0.0;
      for( ib=0; ib<=fnBin+1; ib++) {
         bin  = fWtHst1->GetBinContent(ib);
         bin1 = fWtHst2->GetBinContent(ib);
         if(ib >= ibX) bin1=lowEdge*bin;
         sum   += bin;
         sumWt += bin1;
      }
      aveWt1 = sumWt/sum;
      if( TMath::Abs(1.0-aveWt1/aveWt) > eps ) break;
   }
   //---------------------------
   if(ibX == (fnBin+1) ) {
      wtLim = 1.0e200;
      MCeff   = 0.0;
      Log()<< "+++++ wtLim undefined. Higher uper limit in histogram"<<Endl;
   } else if( ibX == 1) {
      wtLim = 0.0;
      MCeff   =-1.0;
      Log()<< "+++++ wtLim undefined. Lower uper limit or more bins "<<Endl;
   } else {
      wtLim= (ibX)*fwmax/fnBin; // We over-estimate wtLim, under-estimate MCeff
      MCeff  = aveWt/wtLim;
   }
}
///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//      End of    Class  PDEFoamMaxwt                                        //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////
//                                                                            //
// Auxiliary class PDEFoamVect of n-dimensional vector, with dynamic allocation //
// used for the cartesian geometry of the PDEFoam  cells                      //
//                                                                            //
////////////////////////////////////////////////////////////////////////////////

ClassImp(TMVA::PDEFoamVect);

//_____________________________________________________________________________
TMVA::PDEFoamVect::PDEFoamVect():
   fLogger( new MsgLogger("PDEFoamVect") )
{
   // Default constructor for streamer

   fDim    =0;
   fCoords =0;
   fNext   =0;
   fPrev   =0;
}

//______________________________________________________________________________
TMVA::PDEFoamVect::PDEFoamVect(Int_t n):
   fLogger( new MsgLogger("PDEFoamVect") )
{
   // User constructor creating n-dimensional vector
   // and allocating dynamically array of components

   Int_t i;
   fNext=0;
   fPrev=0;
   fDim=n;
   fCoords = 0;
   if (n>0) {
      fCoords = new Double_t[fDim];
      if(gDebug) {
         if(fCoords == 0)
            Error( "PDEFoamVect", "Constructor failed to allocate\n");
      }
      for (i=0; i<n; i++) *(fCoords+i)=0.0;
   }
   if(gDebug) Info("PDEFoamVect", "USER CONSTRUCTOR PDEFoamVect(const Int_t)\n ");
}

//___________________________________________________________________________
TMVA::PDEFoamVect::PDEFoamVect(const PDEFoamVect &Vect):
   TObject(Vect),
   fLogger( new MsgLogger("PDEFoamVect") )
{
   // Copy constructor

   fNext=0;
   fPrev=0;
   fDim=Vect.fDim;
   fCoords = 0;
   if(fDim>0)  fCoords = new Double_t[fDim];
   if(gDebug) {
      if(fCoords == 0) {
         Error( "PDEFoamVect", "Constructor failed to allocate fCoords\n");
      }
   }
   for(Int_t i=0; i<fDim; i++)
      fCoords[i] = Vect.fCoords[i];
   Error( "PDEFoamVect","+++++ NEVER USE Copy constructor !!!!!\n ");
}

//___________________________________________________________________________
TMVA::PDEFoamVect::~PDEFoamVect()
{
   // Destructor
   if(gDebug) Info("PDEFoamVect"," DESTRUCTOR PDEFoamVect~ \n");
   delete [] fCoords; //  free(fCoords)
   fCoords=0;
   delete fLogger;
}


//////////////////////////////////////////////////////////////////////////////
//                     Overloading operators                                //
//////////////////////////////////////////////////////////////////////////////

//____________________________________________________________________________
TMVA::PDEFoamVect& TMVA::PDEFoamVect::operator =(const PDEFoamVect& Vect)
{
   // substitution operator

   Int_t i;
   if (&Vect == this) return *this;
   if( fDim != Vect.fDim )
      Error( "PDEFoamVect","operator=Dims. are different: %d and %d \n ",fDim,Vect.fDim);
   if( fDim != Vect.fDim ) {  // cleanup
      delete [] fCoords;
      fCoords = new Double_t[fDim];
   }
   fDim=Vect.fDim;
   for(i=0; i<fDim; i++)
      fCoords[i] = Vect.fCoords[i];
   fNext=Vect.fNext;
   fPrev=Vect.fPrev;
   if(gDebug)  Info("PDEFoamVect", "SUBSITUTE operator =\n ");
   return *this;
}

//______________________________________________________________________
Double_t &TMVA::PDEFoamVect::operator[](Int_t n)
{
   // [] is for access to elements as in ordinary matrix like a[j]=b[j]
   // (Perhaps against some strict rules but rather practical.)
   // Range protection is built in, consequently for substitution
   // one should use rather use a=b than explicit loop!

   if ((n<0) || (n>=fDim)) {
      Error(  "PDEFoamVect","operator[], out of range \n");
   }
   return fCoords[n];
}

//______________________________________________________________________
TMVA::PDEFoamVect& TMVA::PDEFoamVect::operator*=(const Double_t &x)
{
   // unary multiplication operator *=

   for(Int_t i=0;i<fDim;i++)
      fCoords[i] = fCoords[i]*x;
   return *this;
}

//_______________________________________________________________________
TMVA::PDEFoamVect& TMVA::PDEFoamVect::operator+=(const PDEFoamVect& Shift)
{
   // unary addition operator +=; adding vector c*=x,
   if( fDim != Shift.fDim){
      Error(  "PDEFoamVect","operator+, different dimensions= %d %d \n",fDim,Shift.fDim);
   }
   for(Int_t i=0;i<fDim;i++)
      fCoords[i] = fCoords[i]+Shift.fCoords[i];
   return *this;
}

//________________________________________________________________________
TMVA::PDEFoamVect& TMVA::PDEFoamVect::operator-=(const PDEFoamVect& Shift)
{
   // unary subtraction operator -=
   if( fDim != Shift.fDim) {
      Error(  "PDEFoamVect","operator+, different dimensions= %d %d \n",fDim,Shift.fDim);
   }
   for(Int_t i=0;i<fDim;i++)
      fCoords[i] = fCoords[i]-Shift.fCoords[i];
   return *this;
}

//_________________________________________________________________________
TMVA::PDEFoamVect TMVA::PDEFoamVect::operator+(const PDEFoamVect &p2)
{
   // addition operator +; sum of 2 vectors: c=a+b, a=a+b,
   // NEVER USE IT, VERY SLOW!!!
   PDEFoamVect temp(fDim);
   temp  = (*this);
   temp += p2;
   return temp;
}

//__________________________________________________________________________
TMVA::PDEFoamVect TMVA::PDEFoamVect::operator-(const PDEFoamVect &p2)
{
   // subtraction operator -; difference of 2 vectors; c=a-b, a=a-b,
   // NEVER USE IT, VERY SLOW!!!
   PDEFoamVect temp(fDim);
   temp  = (*this);
   temp -= p2;
   return temp;
}

//___________________________________________________________________________
TMVA::PDEFoamVect& TMVA::PDEFoamVect::operator =(Double_t Vect[])
{
   // Loading in ordinary double prec. vector, sometimes can be useful
   Int_t i;
   for(i=0; i<fDim; i++)
      fCoords[i] = Vect[i];
   return *this;
}

//____________________________________________________________________________
TMVA::PDEFoamVect& TMVA::PDEFoamVect::operator =(Double_t x)
{
   // Loading in double prec. number, sometimes can be useful
   if(fCoords != 0) {
      for(Int_t i=0; i<fDim; i++)
         fCoords[i] = x;
   }
   return *this;
}
//////////////////////////////////////////////////////////////////////////////
//                          OTHER METHODS                                   //
//////////////////////////////////////////////////////////////////////////////

//_____________________________________________________________________________
void TMVA::PDEFoamVect::Print(Option_t *option) const
{
   // Printout of all vector components on "Log()"
   if(!option) Error( "Print ", "No option set \n");
   Int_t i;
   cout << "(";
   for(i=0; i<fDim-1; i++) cout  << SW2 << *(fCoords+i) << ",";
   cout  << SW2 << *(fCoords+fDim-1);
   cout << ")";
}
//______________________________________________________________________________
void TMVA::PDEFoamVect::PrintList(void)
{
   // Printout of all member vectors in the list starting from "this"
   Long_t i=0;
   if(this == 0) return;
   PDEFoamVect *current=this;
   while(current != 0) {
      Log() << "vec["<<i<<"]=";
      current->Print("1");
      Log() << Endl;
      current = current->fNext;
      i++;
   }
}

///////////////////////////////////////////////////////////////////////////////
//                End of Class PDEFoamVect                                     //
///////////////////////////////////////////////////////////////////////////////
 PDEFoam.cxx:1
 PDEFoam.cxx:2
 PDEFoam.cxx:3
 PDEFoam.cxx:4
 PDEFoam.cxx:5
 PDEFoam.cxx:6
 PDEFoam.cxx:7
 PDEFoam.cxx:8
 PDEFoam.cxx:9
 PDEFoam.cxx:10
 PDEFoam.cxx:11
 PDEFoam.cxx:12
 PDEFoam.cxx:13
 PDEFoam.cxx:14
 PDEFoam.cxx:15
 PDEFoam.cxx:16
 PDEFoam.cxx:17
 PDEFoam.cxx:18
 PDEFoam.cxx:19
 PDEFoam.cxx:20
 PDEFoam.cxx:21
 PDEFoam.cxx:22
 PDEFoam.cxx:23
 PDEFoam.cxx:24
 PDEFoam.cxx:25
 PDEFoam.cxx:26
 PDEFoam.cxx:27
 PDEFoam.cxx:28
 PDEFoam.cxx:29
 PDEFoam.cxx:30
 PDEFoam.cxx:31
 PDEFoam.cxx:32
 PDEFoam.cxx:33
 PDEFoam.cxx:34
 PDEFoam.cxx:35
 PDEFoam.cxx:36
 PDEFoam.cxx:37
 PDEFoam.cxx:38
 PDEFoam.cxx:39
 PDEFoam.cxx:40
 PDEFoam.cxx:41
 PDEFoam.cxx:42
 PDEFoam.cxx:43
 PDEFoam.cxx:44
 PDEFoam.cxx:45
 PDEFoam.cxx:46
 PDEFoam.cxx:47
 PDEFoam.cxx:48
 PDEFoam.cxx:49
 PDEFoam.cxx:50
 PDEFoam.cxx:51
 PDEFoam.cxx:52
 PDEFoam.cxx:53
 PDEFoam.cxx:54
 PDEFoam.cxx:55
 PDEFoam.cxx:56
 PDEFoam.cxx:57
 PDEFoam.cxx:58
 PDEFoam.cxx:59
 PDEFoam.cxx:60
 PDEFoam.cxx:61
 PDEFoam.cxx:62
 PDEFoam.cxx:63
 PDEFoam.cxx:64
 PDEFoam.cxx:65
 PDEFoam.cxx:66
 PDEFoam.cxx:67
 PDEFoam.cxx:68
 PDEFoam.cxx:69
 PDEFoam.cxx:70
 PDEFoam.cxx:71
 PDEFoam.cxx:72
 PDEFoam.cxx:73
 PDEFoam.cxx:74
 PDEFoam.cxx:75
 PDEFoam.cxx:76
 PDEFoam.cxx:77
 PDEFoam.cxx:78
 PDEFoam.cxx:79
 PDEFoam.cxx:80
 PDEFoam.cxx:81
 PDEFoam.cxx:82
 PDEFoam.cxx:83
 PDEFoam.cxx:84
 PDEFoam.cxx:85
 PDEFoam.cxx:86
 PDEFoam.cxx:87
 PDEFoam.cxx:88
 PDEFoam.cxx:89
 PDEFoam.cxx:90
 PDEFoam.cxx:91
 PDEFoam.cxx:92
 PDEFoam.cxx:93
 PDEFoam.cxx:94
 PDEFoam.cxx:95
 PDEFoam.cxx:96
 PDEFoam.cxx:97
 PDEFoam.cxx:98
 PDEFoam.cxx:99
 PDEFoam.cxx:100
 PDEFoam.cxx:101
 PDEFoam.cxx:102
 PDEFoam.cxx:103
 PDEFoam.cxx:104
 PDEFoam.cxx:105
 PDEFoam.cxx:106
 PDEFoam.cxx:107
 PDEFoam.cxx:108
 PDEFoam.cxx:109
 PDEFoam.cxx:110
 PDEFoam.cxx:111
 PDEFoam.cxx:112
 PDEFoam.cxx:113
 PDEFoam.cxx:114
 PDEFoam.cxx:115
 PDEFoam.cxx:116
 PDEFoam.cxx:117
 PDEFoam.cxx:118
 PDEFoam.cxx:119
 PDEFoam.cxx:120
 PDEFoam.cxx:121
 PDEFoam.cxx:122
 PDEFoam.cxx:123
 PDEFoam.cxx:124
 PDEFoam.cxx:125
 PDEFoam.cxx:126
 PDEFoam.cxx:127
 PDEFoam.cxx:128
 PDEFoam.cxx:129
 PDEFoam.cxx:130
 PDEFoam.cxx:131
 PDEFoam.cxx:132
 PDEFoam.cxx:133
 PDEFoam.cxx:134
 PDEFoam.cxx:135
 PDEFoam.cxx:136
 PDEFoam.cxx:137
 PDEFoam.cxx:138
 PDEFoam.cxx:139
 PDEFoam.cxx:140
 PDEFoam.cxx:141
 PDEFoam.cxx:142
 PDEFoam.cxx:143
 PDEFoam.cxx:144
 PDEFoam.cxx:145
 PDEFoam.cxx:146
 PDEFoam.cxx:147
 PDEFoam.cxx:148
 PDEFoam.cxx:149
 PDEFoam.cxx:150
 PDEFoam.cxx:151
 PDEFoam.cxx:152
 PDEFoam.cxx:153
 PDEFoam.cxx:154
 PDEFoam.cxx:155
 PDEFoam.cxx:156
 PDEFoam.cxx:157
 PDEFoam.cxx:158
 PDEFoam.cxx:159
 PDEFoam.cxx:160
 PDEFoam.cxx:161
 PDEFoam.cxx:162
 PDEFoam.cxx:163
 PDEFoam.cxx:164
 PDEFoam.cxx:165
 PDEFoam.cxx:166
 PDEFoam.cxx:167
 PDEFoam.cxx:168
 PDEFoam.cxx:169
 PDEFoam.cxx:170
 PDEFoam.cxx:171
 PDEFoam.cxx:172
 PDEFoam.cxx:173
 PDEFoam.cxx:174
 PDEFoam.cxx:175
 PDEFoam.cxx:176
 PDEFoam.cxx:177
 PDEFoam.cxx:178
 PDEFoam.cxx:179
 PDEFoam.cxx:180
 PDEFoam.cxx:181
 PDEFoam.cxx:182
 PDEFoam.cxx:183
 PDEFoam.cxx:184
 PDEFoam.cxx:185
 PDEFoam.cxx:186
 PDEFoam.cxx:187
 PDEFoam.cxx:188
 PDEFoam.cxx:189
 PDEFoam.cxx:190
 PDEFoam.cxx:191
 PDEFoam.cxx:192
 PDEFoam.cxx:193
 PDEFoam.cxx:194
 PDEFoam.cxx:195
 PDEFoam.cxx:196
 PDEFoam.cxx:197
 PDEFoam.cxx:198
 PDEFoam.cxx:199
 PDEFoam.cxx:200
 PDEFoam.cxx:201
 PDEFoam.cxx:202
 PDEFoam.cxx:203
 PDEFoam.cxx:204
 PDEFoam.cxx:205
 PDEFoam.cxx:206
 PDEFoam.cxx:207
 PDEFoam.cxx:208
 PDEFoam.cxx:209
 PDEFoam.cxx:210
 PDEFoam.cxx:211
 PDEFoam.cxx:212
 PDEFoam.cxx:213
 PDEFoam.cxx:214
 PDEFoam.cxx:215
 PDEFoam.cxx:216
 PDEFoam.cxx:217
 PDEFoam.cxx:218
 PDEFoam.cxx:219
 PDEFoam.cxx:220
 PDEFoam.cxx:221
 PDEFoam.cxx:222
 PDEFoam.cxx:223
 PDEFoam.cxx:224
 PDEFoam.cxx:225
 PDEFoam.cxx:226
 PDEFoam.cxx:227
 PDEFoam.cxx:228
 PDEFoam.cxx:229
 PDEFoam.cxx:230
 PDEFoam.cxx:231
 PDEFoam.cxx:232
 PDEFoam.cxx:233
 PDEFoam.cxx:234
 PDEFoam.cxx:235
 PDEFoam.cxx:236
 PDEFoam.cxx:237
 PDEFoam.cxx:238
 PDEFoam.cxx:239
 PDEFoam.cxx:240
 PDEFoam.cxx:241
 PDEFoam.cxx:242
 PDEFoam.cxx:243
 PDEFoam.cxx:244
 PDEFoam.cxx:245
 PDEFoam.cxx:246
 PDEFoam.cxx:247
 PDEFoam.cxx:248
 PDEFoam.cxx:249
 PDEFoam.cxx:250
 PDEFoam.cxx:251
 PDEFoam.cxx:252
 PDEFoam.cxx:253
 PDEFoam.cxx:254
 PDEFoam.cxx:255
 PDEFoam.cxx:256
 PDEFoam.cxx:257
 PDEFoam.cxx:258
 PDEFoam.cxx:259
 PDEFoam.cxx:260
 PDEFoam.cxx:261
 PDEFoam.cxx:262
 PDEFoam.cxx:263
 PDEFoam.cxx:264
 PDEFoam.cxx:265
 PDEFoam.cxx:266
 PDEFoam.cxx:267
 PDEFoam.cxx:268
 PDEFoam.cxx:269
 PDEFoam.cxx:270
 PDEFoam.cxx:271
 PDEFoam.cxx:272
 PDEFoam.cxx:273
 PDEFoam.cxx:274
 PDEFoam.cxx:275
 PDEFoam.cxx:276
 PDEFoam.cxx:277
 PDEFoam.cxx:278
 PDEFoam.cxx:279
 PDEFoam.cxx:280
 PDEFoam.cxx:281
 PDEFoam.cxx:282
 PDEFoam.cxx:283
 PDEFoam.cxx:284
 PDEFoam.cxx:285
 PDEFoam.cxx:286
 PDEFoam.cxx:287
 PDEFoam.cxx:288
 PDEFoam.cxx:289
 PDEFoam.cxx:290
 PDEFoam.cxx:291
 PDEFoam.cxx:292
 PDEFoam.cxx:293
 PDEFoam.cxx:294
 PDEFoam.cxx:295
 PDEFoam.cxx:296
 PDEFoam.cxx:297
 PDEFoam.cxx:298
 PDEFoam.cxx:299
 PDEFoam.cxx:300
 PDEFoam.cxx:301
 PDEFoam.cxx:302
 PDEFoam.cxx:303
 PDEFoam.cxx:304
 PDEFoam.cxx:305
 PDEFoam.cxx:306
 PDEFoam.cxx:307
 PDEFoam.cxx:308
 PDEFoam.cxx:309
 PDEFoam.cxx:310
 PDEFoam.cxx:311
 PDEFoam.cxx:312
 PDEFoam.cxx:313
 PDEFoam.cxx:314
 PDEFoam.cxx:315
 PDEFoam.cxx:316
 PDEFoam.cxx:317
 PDEFoam.cxx:318
 PDEFoam.cxx:319
 PDEFoam.cxx:320
 PDEFoam.cxx:321
 PDEFoam.cxx:322
 PDEFoam.cxx:323
 PDEFoam.cxx:324
 PDEFoam.cxx:325
 PDEFoam.cxx:326
 PDEFoam.cxx:327
 PDEFoam.cxx:328
 PDEFoam.cxx:329
 PDEFoam.cxx:330
 PDEFoam.cxx:331
 PDEFoam.cxx:332
 PDEFoam.cxx:333
 PDEFoam.cxx:334
 PDEFoam.cxx:335
 PDEFoam.cxx:336
 PDEFoam.cxx:337
 PDEFoam.cxx:338
 PDEFoam.cxx:339
 PDEFoam.cxx:340
 PDEFoam.cxx:341
 PDEFoam.cxx:342
 PDEFoam.cxx:343
 PDEFoam.cxx:344
 PDEFoam.cxx:345
 PDEFoam.cxx:346
 PDEFoam.cxx:347
 PDEFoam.cxx:348
 PDEFoam.cxx:349
 PDEFoam.cxx:350
 PDEFoam.cxx:351
 PDEFoam.cxx:352
 PDEFoam.cxx:353
 PDEFoam.cxx:354
 PDEFoam.cxx:355
 PDEFoam.cxx:356
 PDEFoam.cxx:357
 PDEFoam.cxx:358
 PDEFoam.cxx:359
 PDEFoam.cxx:360
 PDEFoam.cxx:361
 PDEFoam.cxx:362
 PDEFoam.cxx:363
 PDEFoam.cxx:364
 PDEFoam.cxx:365
 PDEFoam.cxx:366
 PDEFoam.cxx:367
 PDEFoam.cxx:368
 PDEFoam.cxx:369
 PDEFoam.cxx:370
 PDEFoam.cxx:371
 PDEFoam.cxx:372
 PDEFoam.cxx:373
 PDEFoam.cxx:374
 PDEFoam.cxx:375
 PDEFoam.cxx:376
 PDEFoam.cxx:377
 PDEFoam.cxx:378
 PDEFoam.cxx:379
 PDEFoam.cxx:380
 PDEFoam.cxx:381
 PDEFoam.cxx:382
 PDEFoam.cxx:383
 PDEFoam.cxx:384
 PDEFoam.cxx:385
 PDEFoam.cxx:386
 PDEFoam.cxx:387
 PDEFoam.cxx:388
 PDEFoam.cxx:389
 PDEFoam.cxx:390
 PDEFoam.cxx:391
 PDEFoam.cxx:392
 PDEFoam.cxx:393
 PDEFoam.cxx:394
 PDEFoam.cxx:395
 PDEFoam.cxx:396
 PDEFoam.cxx:397
 PDEFoam.cxx:398
 PDEFoam.cxx:399
 PDEFoam.cxx:400
 PDEFoam.cxx:401
 PDEFoam.cxx:402
 PDEFoam.cxx:403
 PDEFoam.cxx:404
 PDEFoam.cxx:405
 PDEFoam.cxx:406
 PDEFoam.cxx:407
 PDEFoam.cxx:408
 PDEFoam.cxx:409
 PDEFoam.cxx:410
 PDEFoam.cxx:411
 PDEFoam.cxx:412
 PDEFoam.cxx:413
 PDEFoam.cxx:414
 PDEFoam.cxx:415
 PDEFoam.cxx:416
 PDEFoam.cxx:417
 PDEFoam.cxx:418
 PDEFoam.cxx:419
 PDEFoam.cxx:420
 PDEFoam.cxx:421
 PDEFoam.cxx:422
 PDEFoam.cxx:423
 PDEFoam.cxx:424
 PDEFoam.cxx:425
 PDEFoam.cxx:426
 PDEFoam.cxx:427
 PDEFoam.cxx:428
 PDEFoam.cxx:429
 PDEFoam.cxx:430
 PDEFoam.cxx:431
 PDEFoam.cxx:432
 PDEFoam.cxx:433
 PDEFoam.cxx:434
 PDEFoam.cxx:435
 PDEFoam.cxx:436
 PDEFoam.cxx:437
 PDEFoam.cxx:438
 PDEFoam.cxx:439
 PDEFoam.cxx:440
 PDEFoam.cxx:441
 PDEFoam.cxx:442
 PDEFoam.cxx:443
 PDEFoam.cxx:444
 PDEFoam.cxx:445
 PDEFoam.cxx:446
 PDEFoam.cxx:447
 PDEFoam.cxx:448
 PDEFoam.cxx:449
 PDEFoam.cxx:450
 PDEFoam.cxx:451
 PDEFoam.cxx:452
 PDEFoam.cxx:453
 PDEFoam.cxx:454
 PDEFoam.cxx:455
 PDEFoam.cxx:456
 PDEFoam.cxx:457
 PDEFoam.cxx:458
 PDEFoam.cxx:459
 PDEFoam.cxx:460
 PDEFoam.cxx:461
 PDEFoam.cxx:462
 PDEFoam.cxx:463
 PDEFoam.cxx:464
 PDEFoam.cxx:465
 PDEFoam.cxx:466
 PDEFoam.cxx:467
 PDEFoam.cxx:468
 PDEFoam.cxx:469
 PDEFoam.cxx:470
 PDEFoam.cxx:471
 PDEFoam.cxx:472
 PDEFoam.cxx:473
 PDEFoam.cxx:474
 PDEFoam.cxx:475
 PDEFoam.cxx:476
 PDEFoam.cxx:477
 PDEFoam.cxx:478
 PDEFoam.cxx:479
 PDEFoam.cxx:480
 PDEFoam.cxx:481
 PDEFoam.cxx:482
 PDEFoam.cxx:483
 PDEFoam.cxx:484
 PDEFoam.cxx:485
 PDEFoam.cxx:486
 PDEFoam.cxx:487
 PDEFoam.cxx:488
 PDEFoam.cxx:489
 PDEFoam.cxx:490
 PDEFoam.cxx:491
 PDEFoam.cxx:492
 PDEFoam.cxx:493
 PDEFoam.cxx:494
 PDEFoam.cxx:495
 PDEFoam.cxx:496
 PDEFoam.cxx:497
 PDEFoam.cxx:498
 PDEFoam.cxx:499
 PDEFoam.cxx:500
 PDEFoam.cxx:501
 PDEFoam.cxx:502
 PDEFoam.cxx:503
 PDEFoam.cxx:504
 PDEFoam.cxx:505
 PDEFoam.cxx:506
 PDEFoam.cxx:507
 PDEFoam.cxx:508
 PDEFoam.cxx:509
 PDEFoam.cxx:510
 PDEFoam.cxx:511
 PDEFoam.cxx:512
 PDEFoam.cxx:513
 PDEFoam.cxx:514
 PDEFoam.cxx:515
 PDEFoam.cxx:516
 PDEFoam.cxx:517
 PDEFoam.cxx:518
 PDEFoam.cxx:519
 PDEFoam.cxx:520
 PDEFoam.cxx:521
 PDEFoam.cxx:522
 PDEFoam.cxx:523
 PDEFoam.cxx:524
 PDEFoam.cxx:525
 PDEFoam.cxx:526
 PDEFoam.cxx:527
 PDEFoam.cxx:528
 PDEFoam.cxx:529
 PDEFoam.cxx:530
 PDEFoam.cxx:531
 PDEFoam.cxx:532
 PDEFoam.cxx:533
 PDEFoam.cxx:534
 PDEFoam.cxx:535
 PDEFoam.cxx:536
 PDEFoam.cxx:537
 PDEFoam.cxx:538
 PDEFoam.cxx:539
 PDEFoam.cxx:540
 PDEFoam.cxx:541
 PDEFoam.cxx:542
 PDEFoam.cxx:543
 PDEFoam.cxx:544
 PDEFoam.cxx:545
 PDEFoam.cxx:546
 PDEFoam.cxx:547
 PDEFoam.cxx:548
 PDEFoam.cxx:549
 PDEFoam.cxx:550
 PDEFoam.cxx:551
 PDEFoam.cxx:552
 PDEFoam.cxx:553
 PDEFoam.cxx:554
 PDEFoam.cxx:555
 PDEFoam.cxx:556
 PDEFoam.cxx:557
 PDEFoam.cxx:558
 PDEFoam.cxx:559
 PDEFoam.cxx:560
 PDEFoam.cxx:561
 PDEFoam.cxx:562
 PDEFoam.cxx:563
 PDEFoam.cxx:564
 PDEFoam.cxx:565
 PDEFoam.cxx:566
 PDEFoam.cxx:567
 PDEFoam.cxx:568
 PDEFoam.cxx:569
 PDEFoam.cxx:570
 PDEFoam.cxx:571
 PDEFoam.cxx:572
 PDEFoam.cxx:573
 PDEFoam.cxx:574
 PDEFoam.cxx:575
 PDEFoam.cxx:576
 PDEFoam.cxx:577
 PDEFoam.cxx:578
 PDEFoam.cxx:579
 PDEFoam.cxx:580
 PDEFoam.cxx:581
 PDEFoam.cxx:582
 PDEFoam.cxx:583
 PDEFoam.cxx:584
 PDEFoam.cxx:585
 PDEFoam.cxx:586
 PDEFoam.cxx:587
 PDEFoam.cxx:588
 PDEFoam.cxx:589
 PDEFoam.cxx:590
 PDEFoam.cxx:591
 PDEFoam.cxx:592
 PDEFoam.cxx:593
 PDEFoam.cxx:594
 PDEFoam.cxx:595
 PDEFoam.cxx:596
 PDEFoam.cxx:597
 PDEFoam.cxx:598
 PDEFoam.cxx:599
 PDEFoam.cxx:600
 PDEFoam.cxx:601
 PDEFoam.cxx:602
 PDEFoam.cxx:603
 PDEFoam.cxx:604
 PDEFoam.cxx:605
 PDEFoam.cxx:606
 PDEFoam.cxx:607
 PDEFoam.cxx:608
 PDEFoam.cxx:609
 PDEFoam.cxx:610
 PDEFoam.cxx:611
 PDEFoam.cxx:612
 PDEFoam.cxx:613
 PDEFoam.cxx:614
 PDEFoam.cxx:615
 PDEFoam.cxx:616
 PDEFoam.cxx:617
 PDEFoam.cxx:618
 PDEFoam.cxx:619
 PDEFoam.cxx:620
 PDEFoam.cxx:621
 PDEFoam.cxx:622
 PDEFoam.cxx:623
 PDEFoam.cxx:624
 PDEFoam.cxx:625
 PDEFoam.cxx:626
 PDEFoam.cxx:627
 PDEFoam.cxx:628
 PDEFoam.cxx:629
 PDEFoam.cxx:630
 PDEFoam.cxx:631
 PDEFoam.cxx:632
 PDEFoam.cxx:633
 PDEFoam.cxx:634
 PDEFoam.cxx:635
 PDEFoam.cxx:636
 PDEFoam.cxx:637
 PDEFoam.cxx:638
 PDEFoam.cxx:639
 PDEFoam.cxx:640
 PDEFoam.cxx:641
 PDEFoam.cxx:642
 PDEFoam.cxx:643
 PDEFoam.cxx:644
 PDEFoam.cxx:645
 PDEFoam.cxx:646
 PDEFoam.cxx:647
 PDEFoam.cxx:648
 PDEFoam.cxx:649
 PDEFoam.cxx:650
 PDEFoam.cxx:651
 PDEFoam.cxx:652
 PDEFoam.cxx:653
 PDEFoam.cxx:654
 PDEFoam.cxx:655
 PDEFoam.cxx:656
 PDEFoam.cxx:657
 PDEFoam.cxx:658
 PDEFoam.cxx:659
 PDEFoam.cxx:660
 PDEFoam.cxx:661
 PDEFoam.cxx:662
 PDEFoam.cxx:663
 PDEFoam.cxx:664
 PDEFoam.cxx:665
 PDEFoam.cxx:666
 PDEFoam.cxx:667
 PDEFoam.cxx:668
 PDEFoam.cxx:669
 PDEFoam.cxx:670
 PDEFoam.cxx:671
 PDEFoam.cxx:672
 PDEFoam.cxx:673
 PDEFoam.cxx:674
 PDEFoam.cxx:675
 PDEFoam.cxx:676
 PDEFoam.cxx:677
 PDEFoam.cxx:678
 PDEFoam.cxx:679
 PDEFoam.cxx:680
 PDEFoam.cxx:681
 PDEFoam.cxx:682
 PDEFoam.cxx:683
 PDEFoam.cxx:684
 PDEFoam.cxx:685
 PDEFoam.cxx:686
 PDEFoam.cxx:687
 PDEFoam.cxx:688
 PDEFoam.cxx:689
 PDEFoam.cxx:690
 PDEFoam.cxx:691
 PDEFoam.cxx:692
 PDEFoam.cxx:693
 PDEFoam.cxx:694
 PDEFoam.cxx:695
 PDEFoam.cxx:696
 PDEFoam.cxx:697
 PDEFoam.cxx:698
 PDEFoam.cxx:699
 PDEFoam.cxx:700
 PDEFoam.cxx:701
 PDEFoam.cxx:702
 PDEFoam.cxx:703
 PDEFoam.cxx:704
 PDEFoam.cxx:705
 PDEFoam.cxx:706
 PDEFoam.cxx:707
 PDEFoam.cxx:708
 PDEFoam.cxx:709
 PDEFoam.cxx:710
 PDEFoam.cxx:711
 PDEFoam.cxx:712
 PDEFoam.cxx:713
 PDEFoam.cxx:714
 PDEFoam.cxx:715
 PDEFoam.cxx:716
 PDEFoam.cxx:717
 PDEFoam.cxx:718
 PDEFoam.cxx:719
 PDEFoam.cxx:720
 PDEFoam.cxx:721
 PDEFoam.cxx:722
 PDEFoam.cxx:723
 PDEFoam.cxx:724
 PDEFoam.cxx:725
 PDEFoam.cxx:726
 PDEFoam.cxx:727
 PDEFoam.cxx:728
 PDEFoam.cxx:729
 PDEFoam.cxx:730
 PDEFoam.cxx:731
 PDEFoam.cxx:732
 PDEFoam.cxx:733
 PDEFoam.cxx:734
 PDEFoam.cxx:735
 PDEFoam.cxx:736
 PDEFoam.cxx:737
 PDEFoam.cxx:738
 PDEFoam.cxx:739
 PDEFoam.cxx:740
 PDEFoam.cxx:741
 PDEFoam.cxx:742
 PDEFoam.cxx:743
 PDEFoam.cxx:744
 PDEFoam.cxx:745
 PDEFoam.cxx:746
 PDEFoam.cxx:747
 PDEFoam.cxx:748
 PDEFoam.cxx:749
 PDEFoam.cxx:750
 PDEFoam.cxx:751
 PDEFoam.cxx:752
 PDEFoam.cxx:753
 PDEFoam.cxx:754
 PDEFoam.cxx:755
 PDEFoam.cxx:756
 PDEFoam.cxx:757
 PDEFoam.cxx:758
 PDEFoam.cxx:759
 PDEFoam.cxx:760
 PDEFoam.cxx:761
 PDEFoam.cxx:762
 PDEFoam.cxx:763
 PDEFoam.cxx:764
 PDEFoam.cxx:765
 PDEFoam.cxx:766
 PDEFoam.cxx:767
 PDEFoam.cxx:768
 PDEFoam.cxx:769
 PDEFoam.cxx:770
 PDEFoam.cxx:771
 PDEFoam.cxx:772
 PDEFoam.cxx:773
 PDEFoam.cxx:774
 PDEFoam.cxx:775
 PDEFoam.cxx:776
 PDEFoam.cxx:777
 PDEFoam.cxx:778
 PDEFoam.cxx:779
 PDEFoam.cxx:780
 PDEFoam.cxx:781
 PDEFoam.cxx:782
 PDEFoam.cxx:783
 PDEFoam.cxx:784
 PDEFoam.cxx:785
 PDEFoam.cxx:786
 PDEFoam.cxx:787
 PDEFoam.cxx:788
 PDEFoam.cxx:789
 PDEFoam.cxx:790
 PDEFoam.cxx:791
 PDEFoam.cxx:792
 PDEFoam.cxx:793
 PDEFoam.cxx:794
 PDEFoam.cxx:795
 PDEFoam.cxx:796
 PDEFoam.cxx:797
 PDEFoam.cxx:798
 PDEFoam.cxx:799
 PDEFoam.cxx:800
 PDEFoam.cxx:801
 PDEFoam.cxx:802
 PDEFoam.cxx:803
 PDEFoam.cxx:804
 PDEFoam.cxx:805
 PDEFoam.cxx:806
 PDEFoam.cxx:807
 PDEFoam.cxx:808
 PDEFoam.cxx:809
 PDEFoam.cxx:810
 PDEFoam.cxx:811
 PDEFoam.cxx:812
 PDEFoam.cxx:813
 PDEFoam.cxx:814
 PDEFoam.cxx:815
 PDEFoam.cxx:816
 PDEFoam.cxx:817
 PDEFoam.cxx:818
 PDEFoam.cxx:819
 PDEFoam.cxx:820
 PDEFoam.cxx:821
 PDEFoam.cxx:822
 PDEFoam.cxx:823
 PDEFoam.cxx:824
 PDEFoam.cxx:825
 PDEFoam.cxx:826
 PDEFoam.cxx:827
 PDEFoam.cxx:828
 PDEFoam.cxx:829
 PDEFoam.cxx:830
 PDEFoam.cxx:831
 PDEFoam.cxx:832
 PDEFoam.cxx:833
 PDEFoam.cxx:834
 PDEFoam.cxx:835
 PDEFoam.cxx:836
 PDEFoam.cxx:837
 PDEFoam.cxx:838
 PDEFoam.cxx:839
 PDEFoam.cxx:840
 PDEFoam.cxx:841
 PDEFoam.cxx:842
 PDEFoam.cxx:843
 PDEFoam.cxx:844
 PDEFoam.cxx:845
 PDEFoam.cxx:846
 PDEFoam.cxx:847
 PDEFoam.cxx:848
 PDEFoam.cxx:849
 PDEFoam.cxx:850
 PDEFoam.cxx:851
 PDEFoam.cxx:852
 PDEFoam.cxx:853
 PDEFoam.cxx:854
 PDEFoam.cxx:855
 PDEFoam.cxx:856
 PDEFoam.cxx:857
 PDEFoam.cxx:858
 PDEFoam.cxx:859
 PDEFoam.cxx:860
 PDEFoam.cxx:861
 PDEFoam.cxx:862
 PDEFoam.cxx:863
 PDEFoam.cxx:864
 PDEFoam.cxx:865
 PDEFoam.cxx:866
 PDEFoam.cxx:867
 PDEFoam.cxx:868
 PDEFoam.cxx:869
 PDEFoam.cxx:870
 PDEFoam.cxx:871
 PDEFoam.cxx:872
 PDEFoam.cxx:873
 PDEFoam.cxx:874
 PDEFoam.cxx:875
 PDEFoam.cxx:876
 PDEFoam.cxx:877
 PDEFoam.cxx:878
 PDEFoam.cxx:879
 PDEFoam.cxx:880
 PDEFoam.cxx:881
 PDEFoam.cxx:882
 PDEFoam.cxx:883
 PDEFoam.cxx:884
 PDEFoam.cxx:885
 PDEFoam.cxx:886
 PDEFoam.cxx:887
 PDEFoam.cxx:888
 PDEFoam.cxx:889
 PDEFoam.cxx:890
 PDEFoam.cxx:891
 PDEFoam.cxx:892
 PDEFoam.cxx:893
 PDEFoam.cxx:894
 PDEFoam.cxx:895
 PDEFoam.cxx:896
 PDEFoam.cxx:897
 PDEFoam.cxx:898
 PDEFoam.cxx:899
 PDEFoam.cxx:900
 PDEFoam.cxx:901
 PDEFoam.cxx:902
 PDEFoam.cxx:903
 PDEFoam.cxx:904
 PDEFoam.cxx:905
 PDEFoam.cxx:906
 PDEFoam.cxx:907
 PDEFoam.cxx:908
 PDEFoam.cxx:909
 PDEFoam.cxx:910
 PDEFoam.cxx:911
 PDEFoam.cxx:912
 PDEFoam.cxx:913
 PDEFoam.cxx:914
 PDEFoam.cxx:915
 PDEFoam.cxx:916
 PDEFoam.cxx:917
 PDEFoam.cxx:918
 PDEFoam.cxx:919
 PDEFoam.cxx:920
 PDEFoam.cxx:921
 PDEFoam.cxx:922
 PDEFoam.cxx:923
 PDEFoam.cxx:924
 PDEFoam.cxx:925
 PDEFoam.cxx:926
 PDEFoam.cxx:927
 PDEFoam.cxx:928
 PDEFoam.cxx:929
 PDEFoam.cxx:930
 PDEFoam.cxx:931
 PDEFoam.cxx:932
 PDEFoam.cxx:933
 PDEFoam.cxx:934
 PDEFoam.cxx:935
 PDEFoam.cxx:936
 PDEFoam.cxx:937
 PDEFoam.cxx:938
 PDEFoam.cxx:939
 PDEFoam.cxx:940
 PDEFoam.cxx:941
 PDEFoam.cxx:942
 PDEFoam.cxx:943
 PDEFoam.cxx:944
 PDEFoam.cxx:945
 PDEFoam.cxx:946
 PDEFoam.cxx:947
 PDEFoam.cxx:948
 PDEFoam.cxx:949
 PDEFoam.cxx:950
 PDEFoam.cxx:951
 PDEFoam.cxx:952
 PDEFoam.cxx:953
 PDEFoam.cxx:954
 PDEFoam.cxx:955
 PDEFoam.cxx:956
 PDEFoam.cxx:957
 PDEFoam.cxx:958
 PDEFoam.cxx:959
 PDEFoam.cxx:960
 PDEFoam.cxx:961
 PDEFoam.cxx:962
 PDEFoam.cxx:963
 PDEFoam.cxx:964
 PDEFoam.cxx:965
 PDEFoam.cxx:966
 PDEFoam.cxx:967
 PDEFoam.cxx:968
 PDEFoam.cxx:969
 PDEFoam.cxx:970
 PDEFoam.cxx:971
 PDEFoam.cxx:972
 PDEFoam.cxx:973
 PDEFoam.cxx:974
 PDEFoam.cxx:975
 PDEFoam.cxx:976
 PDEFoam.cxx:977
 PDEFoam.cxx:978
 PDEFoam.cxx:979
 PDEFoam.cxx:980
 PDEFoam.cxx:981
 PDEFoam.cxx:982
 PDEFoam.cxx:983
 PDEFoam.cxx:984
 PDEFoam.cxx:985
 PDEFoam.cxx:986
 PDEFoam.cxx:987
 PDEFoam.cxx:988
 PDEFoam.cxx:989
 PDEFoam.cxx:990
 PDEFoam.cxx:991
 PDEFoam.cxx:992
 PDEFoam.cxx:993
 PDEFoam.cxx:994
 PDEFoam.cxx:995
 PDEFoam.cxx:996
 PDEFoam.cxx:997
 PDEFoam.cxx:998
 PDEFoam.cxx:999
 PDEFoam.cxx:1000
 PDEFoam.cxx:1001
 PDEFoam.cxx:1002
 PDEFoam.cxx:1003
 PDEFoam.cxx:1004
 PDEFoam.cxx:1005
 PDEFoam.cxx:1006
 PDEFoam.cxx:1007
 PDEFoam.cxx:1008
 PDEFoam.cxx:1009
 PDEFoam.cxx:1010
 PDEFoam.cxx:1011
 PDEFoam.cxx:1012
 PDEFoam.cxx:1013
 PDEFoam.cxx:1014
 PDEFoam.cxx:1015
 PDEFoam.cxx:1016
 PDEFoam.cxx:1017
 PDEFoam.cxx:1018
 PDEFoam.cxx:1019
 PDEFoam.cxx:1020
 PDEFoam.cxx:1021
 PDEFoam.cxx:1022
 PDEFoam.cxx:1023
 PDEFoam.cxx:1024
 PDEFoam.cxx:1025
 PDEFoam.cxx:1026
 PDEFoam.cxx:1027
 PDEFoam.cxx:1028
 PDEFoam.cxx:1029
 PDEFoam.cxx:1030
 PDEFoam.cxx:1031
 PDEFoam.cxx:1032
 PDEFoam.cxx:1033
 PDEFoam.cxx:1034
 PDEFoam.cxx:1035
 PDEFoam.cxx:1036
 PDEFoam.cxx:1037
 PDEFoam.cxx:1038
 PDEFoam.cxx:1039
 PDEFoam.cxx:1040
 PDEFoam.cxx:1041
 PDEFoam.cxx:1042
 PDEFoam.cxx:1043
 PDEFoam.cxx:1044
 PDEFoam.cxx:1045
 PDEFoam.cxx:1046
 PDEFoam.cxx:1047
 PDEFoam.cxx:1048
 PDEFoam.cxx:1049
 PDEFoam.cxx:1050
 PDEFoam.cxx:1051
 PDEFoam.cxx:1052
 PDEFoam.cxx:1053
 PDEFoam.cxx:1054
 PDEFoam.cxx:1055
 PDEFoam.cxx:1056
 PDEFoam.cxx:1057
 PDEFoam.cxx:1058
 PDEFoam.cxx:1059
 PDEFoam.cxx:1060
 PDEFoam.cxx:1061
 PDEFoam.cxx:1062
 PDEFoam.cxx:1063
 PDEFoam.cxx:1064
 PDEFoam.cxx:1065
 PDEFoam.cxx:1066
 PDEFoam.cxx:1067
 PDEFoam.cxx:1068
 PDEFoam.cxx:1069
 PDEFoam.cxx:1070
 PDEFoam.cxx:1071
 PDEFoam.cxx:1072
 PDEFoam.cxx:1073
 PDEFoam.cxx:1074
 PDEFoam.cxx:1075
 PDEFoam.cxx:1076
 PDEFoam.cxx:1077
 PDEFoam.cxx:1078
 PDEFoam.cxx:1079
 PDEFoam.cxx:1080
 PDEFoam.cxx:1081
 PDEFoam.cxx:1082
 PDEFoam.cxx:1083
 PDEFoam.cxx:1084
 PDEFoam.cxx:1085
 PDEFoam.cxx:1086
 PDEFoam.cxx:1087
 PDEFoam.cxx:1088
 PDEFoam.cxx:1089
 PDEFoam.cxx:1090
 PDEFoam.cxx:1091
 PDEFoam.cxx:1092
 PDEFoam.cxx:1093
 PDEFoam.cxx:1094
 PDEFoam.cxx:1095
 PDEFoam.cxx:1096
 PDEFoam.cxx:1097
 PDEFoam.cxx:1098
 PDEFoam.cxx:1099
 PDEFoam.cxx:1100
 PDEFoam.cxx:1101
 PDEFoam.cxx:1102
 PDEFoam.cxx:1103
 PDEFoam.cxx:1104
 PDEFoam.cxx:1105
 PDEFoam.cxx:1106
 PDEFoam.cxx:1107
 PDEFoam.cxx:1108
 PDEFoam.cxx:1109
 PDEFoam.cxx:1110
 PDEFoam.cxx:1111
 PDEFoam.cxx:1112
 PDEFoam.cxx:1113
 PDEFoam.cxx:1114
 PDEFoam.cxx:1115
 PDEFoam.cxx:1116
 PDEFoam.cxx:1117
 PDEFoam.cxx:1118
 PDEFoam.cxx:1119
 PDEFoam.cxx:1120
 PDEFoam.cxx:1121
 PDEFoam.cxx:1122
 PDEFoam.cxx:1123
 PDEFoam.cxx:1124
 PDEFoam.cxx:1125
 PDEFoam.cxx:1126
 PDEFoam.cxx:1127
 PDEFoam.cxx:1128
 PDEFoam.cxx:1129
 PDEFoam.cxx:1130
 PDEFoam.cxx:1131
 PDEFoam.cxx:1132
 PDEFoam.cxx:1133
 PDEFoam.cxx:1134
 PDEFoam.cxx:1135
 PDEFoam.cxx:1136
 PDEFoam.cxx:1137
 PDEFoam.cxx:1138
 PDEFoam.cxx:1139
 PDEFoam.cxx:1140
 PDEFoam.cxx:1141
 PDEFoam.cxx:1142
 PDEFoam.cxx:1143
 PDEFoam.cxx:1144
 PDEFoam.cxx:1145
 PDEFoam.cxx:1146
 PDEFoam.cxx:1147
 PDEFoam.cxx:1148
 PDEFoam.cxx:1149
 PDEFoam.cxx:1150
 PDEFoam.cxx:1151
 PDEFoam.cxx:1152
 PDEFoam.cxx:1153
 PDEFoam.cxx:1154
 PDEFoam.cxx:1155
 PDEFoam.cxx:1156
 PDEFoam.cxx:1157
 PDEFoam.cxx:1158
 PDEFoam.cxx:1159
 PDEFoam.cxx:1160
 PDEFoam.cxx:1161
 PDEFoam.cxx:1162
 PDEFoam.cxx:1163
 PDEFoam.cxx:1164
 PDEFoam.cxx:1165
 PDEFoam.cxx:1166
 PDEFoam.cxx:1167
 PDEFoam.cxx:1168
 PDEFoam.cxx:1169
 PDEFoam.cxx:1170
 PDEFoam.cxx:1171
 PDEFoam.cxx:1172
 PDEFoam.cxx:1173
 PDEFoam.cxx:1174
 PDEFoam.cxx:1175
 PDEFoam.cxx:1176
 PDEFoam.cxx:1177
 PDEFoam.cxx:1178
 PDEFoam.cxx:1179
 PDEFoam.cxx:1180
 PDEFoam.cxx:1181
 PDEFoam.cxx:1182
 PDEFoam.cxx:1183
 PDEFoam.cxx:1184
 PDEFoam.cxx:1185
 PDEFoam.cxx:1186
 PDEFoam.cxx:1187
 PDEFoam.cxx:1188
 PDEFoam.cxx:1189
 PDEFoam.cxx:1190
 PDEFoam.cxx:1191
 PDEFoam.cxx:1192
 PDEFoam.cxx:1193
 PDEFoam.cxx:1194
 PDEFoam.cxx:1195
 PDEFoam.cxx:1196
 PDEFoam.cxx:1197
 PDEFoam.cxx:1198
 PDEFoam.cxx:1199
 PDEFoam.cxx:1200
 PDEFoam.cxx:1201
 PDEFoam.cxx:1202
 PDEFoam.cxx:1203
 PDEFoam.cxx:1204
 PDEFoam.cxx:1205
 PDEFoam.cxx:1206
 PDEFoam.cxx:1207
 PDEFoam.cxx:1208
 PDEFoam.cxx:1209
 PDEFoam.cxx:1210
 PDEFoam.cxx:1211
 PDEFoam.cxx:1212
 PDEFoam.cxx:1213
 PDEFoam.cxx:1214
 PDEFoam.cxx:1215
 PDEFoam.cxx:1216
 PDEFoam.cxx:1217
 PDEFoam.cxx:1218
 PDEFoam.cxx:1219
 PDEFoam.cxx:1220
 PDEFoam.cxx:1221
 PDEFoam.cxx:1222
 PDEFoam.cxx:1223
 PDEFoam.cxx:1224
 PDEFoam.cxx:1225
 PDEFoam.cxx:1226
 PDEFoam.cxx:1227
 PDEFoam.cxx:1228
 PDEFoam.cxx:1229
 PDEFoam.cxx:1230
 PDEFoam.cxx:1231
 PDEFoam.cxx:1232
 PDEFoam.cxx:1233
 PDEFoam.cxx:1234
 PDEFoam.cxx:1235
 PDEFoam.cxx:1236
 PDEFoam.cxx:1237
 PDEFoam.cxx:1238
 PDEFoam.cxx:1239
 PDEFoam.cxx:1240
 PDEFoam.cxx:1241
 PDEFoam.cxx:1242
 PDEFoam.cxx:1243
 PDEFoam.cxx:1244
 PDEFoam.cxx:1245
 PDEFoam.cxx:1246
 PDEFoam.cxx:1247
 PDEFoam.cxx:1248
 PDEFoam.cxx:1249
 PDEFoam.cxx:1250
 PDEFoam.cxx:1251
 PDEFoam.cxx:1252
 PDEFoam.cxx:1253
 PDEFoam.cxx:1254
 PDEFoam.cxx:1255
 PDEFoam.cxx:1256
 PDEFoam.cxx:1257
 PDEFoam.cxx:1258
 PDEFoam.cxx:1259
 PDEFoam.cxx:1260
 PDEFoam.cxx:1261
 PDEFoam.cxx:1262
 PDEFoam.cxx:1263
 PDEFoam.cxx:1264
 PDEFoam.cxx:1265
 PDEFoam.cxx:1266
 PDEFoam.cxx:1267
 PDEFoam.cxx:1268
 PDEFoam.cxx:1269
 PDEFoam.cxx:1270
 PDEFoam.cxx:1271
 PDEFoam.cxx:1272
 PDEFoam.cxx:1273
 PDEFoam.cxx:1274
 PDEFoam.cxx:1275
 PDEFoam.cxx:1276
 PDEFoam.cxx:1277
 PDEFoam.cxx:1278
 PDEFoam.cxx:1279
 PDEFoam.cxx:1280
 PDEFoam.cxx:1281
 PDEFoam.cxx:1282
 PDEFoam.cxx:1283
 PDEFoam.cxx:1284
 PDEFoam.cxx:1285
 PDEFoam.cxx:1286
 PDEFoam.cxx:1287
 PDEFoam.cxx:1288
 PDEFoam.cxx:1289
 PDEFoam.cxx:1290
 PDEFoam.cxx:1291
 PDEFoam.cxx:1292
 PDEFoam.cxx:1293
 PDEFoam.cxx:1294
 PDEFoam.cxx:1295
 PDEFoam.cxx:1296
 PDEFoam.cxx:1297
 PDEFoam.cxx:1298
 PDEFoam.cxx:1299
 PDEFoam.cxx:1300
 PDEFoam.cxx:1301
 PDEFoam.cxx:1302
 PDEFoam.cxx:1303
 PDEFoam.cxx:1304
 PDEFoam.cxx:1305
 PDEFoam.cxx:1306
 PDEFoam.cxx:1307
 PDEFoam.cxx:1308
 PDEFoam.cxx:1309
 PDEFoam.cxx:1310
 PDEFoam.cxx:1311
 PDEFoam.cxx:1312
 PDEFoam.cxx:1313
 PDEFoam.cxx:1314
 PDEFoam.cxx:1315
 PDEFoam.cxx:1316
 PDEFoam.cxx:1317
 PDEFoam.cxx:1318
 PDEFoam.cxx:1319
 PDEFoam.cxx:1320
 PDEFoam.cxx:1321
 PDEFoam.cxx:1322
 PDEFoam.cxx:1323
 PDEFoam.cxx:1324
 PDEFoam.cxx:1325
 PDEFoam.cxx:1326
 PDEFoam.cxx:1327
 PDEFoam.cxx:1328
 PDEFoam.cxx:1329
 PDEFoam.cxx:1330
 PDEFoam.cxx:1331
 PDEFoam.cxx:1332
 PDEFoam.cxx:1333
 PDEFoam.cxx:1334
 PDEFoam.cxx:1335
 PDEFoam.cxx:1336
 PDEFoam.cxx:1337
 PDEFoam.cxx:1338
 PDEFoam.cxx:1339
 PDEFoam.cxx:1340
 PDEFoam.cxx:1341
 PDEFoam.cxx:1342
 PDEFoam.cxx:1343
 PDEFoam.cxx:1344
 PDEFoam.cxx:1345
 PDEFoam.cxx:1346
 PDEFoam.cxx:1347
 PDEFoam.cxx:1348
 PDEFoam.cxx:1349
 PDEFoam.cxx:1350
 PDEFoam.cxx:1351
 PDEFoam.cxx:1352
 PDEFoam.cxx:1353
 PDEFoam.cxx:1354
 PDEFoam.cxx:1355
 PDEFoam.cxx:1356
 PDEFoam.cxx:1357
 PDEFoam.cxx:1358
 PDEFoam.cxx:1359
 PDEFoam.cxx:1360
 PDEFoam.cxx:1361
 PDEFoam.cxx:1362
 PDEFoam.cxx:1363
 PDEFoam.cxx:1364
 PDEFoam.cxx:1365
 PDEFoam.cxx:1366
 PDEFoam.cxx:1367
 PDEFoam.cxx:1368
 PDEFoam.cxx:1369
 PDEFoam.cxx:1370
 PDEFoam.cxx:1371
 PDEFoam.cxx:1372
 PDEFoam.cxx:1373
 PDEFoam.cxx:1374
 PDEFoam.cxx:1375
 PDEFoam.cxx:1376
 PDEFoam.cxx:1377
 PDEFoam.cxx:1378
 PDEFoam.cxx:1379
 PDEFoam.cxx:1380
 PDEFoam.cxx:1381
 PDEFoam.cxx:1382
 PDEFoam.cxx:1383
 PDEFoam.cxx:1384
 PDEFoam.cxx:1385
 PDEFoam.cxx:1386
 PDEFoam.cxx:1387
 PDEFoam.cxx:1388
 PDEFoam.cxx:1389
 PDEFoam.cxx:1390
 PDEFoam.cxx:1391
 PDEFoam.cxx:1392
 PDEFoam.cxx:1393
 PDEFoam.cxx:1394
 PDEFoam.cxx:1395
 PDEFoam.cxx:1396
 PDEFoam.cxx:1397
 PDEFoam.cxx:1398
 PDEFoam.cxx:1399
 PDEFoam.cxx:1400
 PDEFoam.cxx:1401
 PDEFoam.cxx:1402
 PDEFoam.cxx:1403
 PDEFoam.cxx:1404
 PDEFoam.cxx:1405
 PDEFoam.cxx:1406
 PDEFoam.cxx:1407
 PDEFoam.cxx:1408
 PDEFoam.cxx:1409
 PDEFoam.cxx:1410
 PDEFoam.cxx:1411
 PDEFoam.cxx:1412
 PDEFoam.cxx:1413
 PDEFoam.cxx:1414
 PDEFoam.cxx:1415
 PDEFoam.cxx:1416
 PDEFoam.cxx:1417
 PDEFoam.cxx:1418
 PDEFoam.cxx:1419
 PDEFoam.cxx:1420
 PDEFoam.cxx:1421
 PDEFoam.cxx:1422
 PDEFoam.cxx:1423
 PDEFoam.cxx:1424
 PDEFoam.cxx:1425
 PDEFoam.cxx:1426
 PDEFoam.cxx:1427
 PDEFoam.cxx:1428
 PDEFoam.cxx:1429
 PDEFoam.cxx:1430
 PDEFoam.cxx:1431
 PDEFoam.cxx:1432
 PDEFoam.cxx:1433
 PDEFoam.cxx:1434
 PDEFoam.cxx:1435
 PDEFoam.cxx:1436
 PDEFoam.cxx:1437
 PDEFoam.cxx:1438
 PDEFoam.cxx:1439
 PDEFoam.cxx:1440
 PDEFoam.cxx:1441
 PDEFoam.cxx:1442
 PDEFoam.cxx:1443
 PDEFoam.cxx:1444
 PDEFoam.cxx:1445
 PDEFoam.cxx:1446
 PDEFoam.cxx:1447
 PDEFoam.cxx:1448
 PDEFoam.cxx:1449
 PDEFoam.cxx:1450
 PDEFoam.cxx:1451
 PDEFoam.cxx:1452
 PDEFoam.cxx:1453
 PDEFoam.cxx:1454
 PDEFoam.cxx:1455
 PDEFoam.cxx:1456
 PDEFoam.cxx:1457
 PDEFoam.cxx:1458
 PDEFoam.cxx:1459
 PDEFoam.cxx:1460
 PDEFoam.cxx:1461
 PDEFoam.cxx:1462
 PDEFoam.cxx:1463
 PDEFoam.cxx:1464
 PDEFoam.cxx:1465
 PDEFoam.cxx:1466
 PDEFoam.cxx:1467
 PDEFoam.cxx:1468
 PDEFoam.cxx:1469
 PDEFoam.cxx:1470
 PDEFoam.cxx:1471
 PDEFoam.cxx:1472
 PDEFoam.cxx:1473
 PDEFoam.cxx:1474
 PDEFoam.cxx:1475
 PDEFoam.cxx:1476
 PDEFoam.cxx:1477
 PDEFoam.cxx:1478
 PDEFoam.cxx:1479
 PDEFoam.cxx:1480
 PDEFoam.cxx:1481
 PDEFoam.cxx:1482
 PDEFoam.cxx:1483
 PDEFoam.cxx:1484
 PDEFoam.cxx:1485
 PDEFoam.cxx:1486
 PDEFoam.cxx:1487
 PDEFoam.cxx:1488
 PDEFoam.cxx:1489
 PDEFoam.cxx:1490
 PDEFoam.cxx:1491
 PDEFoam.cxx:1492
 PDEFoam.cxx:1493
 PDEFoam.cxx:1494
 PDEFoam.cxx:1495
 PDEFoam.cxx:1496
 PDEFoam.cxx:1497
 PDEFoam.cxx:1498
 PDEFoam.cxx:1499
 PDEFoam.cxx:1500
 PDEFoam.cxx:1501
 PDEFoam.cxx:1502
 PDEFoam.cxx:1503
 PDEFoam.cxx:1504
 PDEFoam.cxx:1505
 PDEFoam.cxx:1506
 PDEFoam.cxx:1507
 PDEFoam.cxx:1508
 PDEFoam.cxx:1509
 PDEFoam.cxx:1510
 PDEFoam.cxx:1511
 PDEFoam.cxx:1512
 PDEFoam.cxx:1513
 PDEFoam.cxx:1514
 PDEFoam.cxx:1515
 PDEFoam.cxx:1516
 PDEFoam.cxx:1517
 PDEFoam.cxx:1518
 PDEFoam.cxx:1519
 PDEFoam.cxx:1520
 PDEFoam.cxx:1521
 PDEFoam.cxx:1522
 PDEFoam.cxx:1523
 PDEFoam.cxx:1524
 PDEFoam.cxx:1525
 PDEFoam.cxx:1526
 PDEFoam.cxx:1527
 PDEFoam.cxx:1528
 PDEFoam.cxx:1529
 PDEFoam.cxx:1530
 PDEFoam.cxx:1531
 PDEFoam.cxx:1532
 PDEFoam.cxx:1533
 PDEFoam.cxx:1534
 PDEFoam.cxx:1535
 PDEFoam.cxx:1536
 PDEFoam.cxx:1537
 PDEFoam.cxx:1538
 PDEFoam.cxx:1539
 PDEFoam.cxx:1540
 PDEFoam.cxx:1541
 PDEFoam.cxx:1542
 PDEFoam.cxx:1543
 PDEFoam.cxx:1544
 PDEFoam.cxx:1545
 PDEFoam.cxx:1546
 PDEFoam.cxx:1547
 PDEFoam.cxx:1548
 PDEFoam.cxx:1549
 PDEFoam.cxx:1550
 PDEFoam.cxx:1551
 PDEFoam.cxx:1552
 PDEFoam.cxx:1553
 PDEFoam.cxx:1554
 PDEFoam.cxx:1555
 PDEFoam.cxx:1556
 PDEFoam.cxx:1557
 PDEFoam.cxx:1558
 PDEFoam.cxx:1559
 PDEFoam.cxx:1560
 PDEFoam.cxx:1561
 PDEFoam.cxx:1562
 PDEFoam.cxx:1563
 PDEFoam.cxx:1564
 PDEFoam.cxx:1565
 PDEFoam.cxx:1566
 PDEFoam.cxx:1567
 PDEFoam.cxx:1568
 PDEFoam.cxx:1569
 PDEFoam.cxx:1570
 PDEFoam.cxx:1571
 PDEFoam.cxx:1572
 PDEFoam.cxx:1573
 PDEFoam.cxx:1574
 PDEFoam.cxx:1575
 PDEFoam.cxx:1576
 PDEFoam.cxx:1577
 PDEFoam.cxx:1578
 PDEFoam.cxx:1579
 PDEFoam.cxx:1580
 PDEFoam.cxx:1581
 PDEFoam.cxx:1582
 PDEFoam.cxx:1583
 PDEFoam.cxx:1584
 PDEFoam.cxx:1585
 PDEFoam.cxx:1586
 PDEFoam.cxx:1587
 PDEFoam.cxx:1588
 PDEFoam.cxx:1589
 PDEFoam.cxx:1590
 PDEFoam.cxx:1591
 PDEFoam.cxx:1592
 PDEFoam.cxx:1593
 PDEFoam.cxx:1594
 PDEFoam.cxx:1595
 PDEFoam.cxx:1596
 PDEFoam.cxx:1597
 PDEFoam.cxx:1598
 PDEFoam.cxx:1599
 PDEFoam.cxx:1600
 PDEFoam.cxx:1601
 PDEFoam.cxx:1602
 PDEFoam.cxx:1603
 PDEFoam.cxx:1604
 PDEFoam.cxx:1605
 PDEFoam.cxx:1606
 PDEFoam.cxx:1607
 PDEFoam.cxx:1608
 PDEFoam.cxx:1609
 PDEFoam.cxx:1610
 PDEFoam.cxx:1611
 PDEFoam.cxx:1612
 PDEFoam.cxx:1613
 PDEFoam.cxx:1614
 PDEFoam.cxx:1615
 PDEFoam.cxx:1616
 PDEFoam.cxx:1617
 PDEFoam.cxx:1618
 PDEFoam.cxx:1619
 PDEFoam.cxx:1620
 PDEFoam.cxx:1621
 PDEFoam.cxx:1622
 PDEFoam.cxx:1623
 PDEFoam.cxx:1624
 PDEFoam.cxx:1625
 PDEFoam.cxx:1626
 PDEFoam.cxx:1627
 PDEFoam.cxx:1628
 PDEFoam.cxx:1629
 PDEFoam.cxx:1630
 PDEFoam.cxx:1631
 PDEFoam.cxx:1632
 PDEFoam.cxx:1633
 PDEFoam.cxx:1634
 PDEFoam.cxx:1635
 PDEFoam.cxx:1636
 PDEFoam.cxx:1637
 PDEFoam.cxx:1638
 PDEFoam.cxx:1639
 PDEFoam.cxx:1640
 PDEFoam.cxx:1641
 PDEFoam.cxx:1642
 PDEFoam.cxx:1643
 PDEFoam.cxx:1644
 PDEFoam.cxx:1645
 PDEFoam.cxx:1646
 PDEFoam.cxx:1647
 PDEFoam.cxx:1648
 PDEFoam.cxx:1649
 PDEFoam.cxx:1650
 PDEFoam.cxx:1651
 PDEFoam.cxx:1652
 PDEFoam.cxx:1653
 PDEFoam.cxx:1654
 PDEFoam.cxx:1655
 PDEFoam.cxx:1656
 PDEFoam.cxx:1657
 PDEFoam.cxx:1658
 PDEFoam.cxx:1659
 PDEFoam.cxx:1660
 PDEFoam.cxx:1661
 PDEFoam.cxx:1662
 PDEFoam.cxx:1663
 PDEFoam.cxx:1664
 PDEFoam.cxx:1665
 PDEFoam.cxx:1666
 PDEFoam.cxx:1667
 PDEFoam.cxx:1668
 PDEFoam.cxx:1669
 PDEFoam.cxx:1670
 PDEFoam.cxx:1671
 PDEFoam.cxx:1672
 PDEFoam.cxx:1673
 PDEFoam.cxx:1674
 PDEFoam.cxx:1675
 PDEFoam.cxx:1676
 PDEFoam.cxx:1677
 PDEFoam.cxx:1678
 PDEFoam.cxx:1679
 PDEFoam.cxx:1680
 PDEFoam.cxx:1681
 PDEFoam.cxx:1682
 PDEFoam.cxx:1683
 PDEFoam.cxx:1684
 PDEFoam.cxx:1685
 PDEFoam.cxx:1686
 PDEFoam.cxx:1687
 PDEFoam.cxx:1688
 PDEFoam.cxx:1689
 PDEFoam.cxx:1690
 PDEFoam.cxx:1691
 PDEFoam.cxx:1692
 PDEFoam.cxx:1693
 PDEFoam.cxx:1694
 PDEFoam.cxx:1695
 PDEFoam.cxx:1696
 PDEFoam.cxx:1697
 PDEFoam.cxx:1698
 PDEFoam.cxx:1699
 PDEFoam.cxx:1700
 PDEFoam.cxx:1701
 PDEFoam.cxx:1702
 PDEFoam.cxx:1703
 PDEFoam.cxx:1704
 PDEFoam.cxx:1705
 PDEFoam.cxx:1706
 PDEFoam.cxx:1707
 PDEFoam.cxx:1708
 PDEFoam.cxx:1709
 PDEFoam.cxx:1710
 PDEFoam.cxx:1711
 PDEFoam.cxx:1712
 PDEFoam.cxx:1713
 PDEFoam.cxx:1714
 PDEFoam.cxx:1715
 PDEFoam.cxx:1716
 PDEFoam.cxx:1717
 PDEFoam.cxx:1718
 PDEFoam.cxx:1719
 PDEFoam.cxx:1720
 PDEFoam.cxx:1721
 PDEFoam.cxx:1722
 PDEFoam.cxx:1723
 PDEFoam.cxx:1724
 PDEFoam.cxx:1725
 PDEFoam.cxx:1726
 PDEFoam.cxx:1727
 PDEFoam.cxx:1728
 PDEFoam.cxx:1729
 PDEFoam.cxx:1730
 PDEFoam.cxx:1731
 PDEFoam.cxx:1732
 PDEFoam.cxx:1733
 PDEFoam.cxx:1734
 PDEFoam.cxx:1735
 PDEFoam.cxx:1736
 PDEFoam.cxx:1737
 PDEFoam.cxx:1738
 PDEFoam.cxx:1739
 PDEFoam.cxx:1740
 PDEFoam.cxx:1741
 PDEFoam.cxx:1742
 PDEFoam.cxx:1743
 PDEFoam.cxx:1744
 PDEFoam.cxx:1745
 PDEFoam.cxx:1746
 PDEFoam.cxx:1747
 PDEFoam.cxx:1748
 PDEFoam.cxx:1749
 PDEFoam.cxx:1750
 PDEFoam.cxx:1751
 PDEFoam.cxx:1752
 PDEFoam.cxx:1753
 PDEFoam.cxx:1754
 PDEFoam.cxx:1755
 PDEFoam.cxx:1756
 PDEFoam.cxx:1757
 PDEFoam.cxx:1758
 PDEFoam.cxx:1759
 PDEFoam.cxx:1760
 PDEFoam.cxx:1761
 PDEFoam.cxx:1762
 PDEFoam.cxx:1763
 PDEFoam.cxx:1764
 PDEFoam.cxx:1765
 PDEFoam.cxx:1766
 PDEFoam.cxx:1767
 PDEFoam.cxx:1768
 PDEFoam.cxx:1769
 PDEFoam.cxx:1770
 PDEFoam.cxx:1771
 PDEFoam.cxx:1772
 PDEFoam.cxx:1773
 PDEFoam.cxx:1774
 PDEFoam.cxx:1775
 PDEFoam.cxx:1776
 PDEFoam.cxx:1777
 PDEFoam.cxx:1778
 PDEFoam.cxx:1779
 PDEFoam.cxx:1780
 PDEFoam.cxx:1781
 PDEFoam.cxx:1782
 PDEFoam.cxx:1783
 PDEFoam.cxx:1784
 PDEFoam.cxx:1785
 PDEFoam.cxx:1786
 PDEFoam.cxx:1787
 PDEFoam.cxx:1788
 PDEFoam.cxx:1789
 PDEFoam.cxx:1790
 PDEFoam.cxx:1791
 PDEFoam.cxx:1792
 PDEFoam.cxx:1793
 PDEFoam.cxx:1794
 PDEFoam.cxx:1795
 PDEFoam.cxx:1796
 PDEFoam.cxx:1797
 PDEFoam.cxx:1798
 PDEFoam.cxx:1799
 PDEFoam.cxx:1800
 PDEFoam.cxx:1801
 PDEFoam.cxx:1802
 PDEFoam.cxx:1803
 PDEFoam.cxx:1804
 PDEFoam.cxx:1805
 PDEFoam.cxx:1806
 PDEFoam.cxx:1807
 PDEFoam.cxx:1808
 PDEFoam.cxx:1809
 PDEFoam.cxx:1810
 PDEFoam.cxx:1811
 PDEFoam.cxx:1812
 PDEFoam.cxx:1813
 PDEFoam.cxx:1814
 PDEFoam.cxx:1815
 PDEFoam.cxx:1816
 PDEFoam.cxx:1817
 PDEFoam.cxx:1818
 PDEFoam.cxx:1819
 PDEFoam.cxx:1820
 PDEFoam.cxx:1821
 PDEFoam.cxx:1822
 PDEFoam.cxx:1823
 PDEFoam.cxx:1824
 PDEFoam.cxx:1825
 PDEFoam.cxx:1826
 PDEFoam.cxx:1827
 PDEFoam.cxx:1828
 PDEFoam.cxx:1829
 PDEFoam.cxx:1830
 PDEFoam.cxx:1831
 PDEFoam.cxx:1832
 PDEFoam.cxx:1833
 PDEFoam.cxx:1834
 PDEFoam.cxx:1835
 PDEFoam.cxx:1836
 PDEFoam.cxx:1837
 PDEFoam.cxx:1838
 PDEFoam.cxx:1839
 PDEFoam.cxx:1840
 PDEFoam.cxx:1841
 PDEFoam.cxx:1842
 PDEFoam.cxx:1843
 PDEFoam.cxx:1844
 PDEFoam.cxx:1845
 PDEFoam.cxx:1846
 PDEFoam.cxx:1847
 PDEFoam.cxx:1848
 PDEFoam.cxx:1849
 PDEFoam.cxx:1850
 PDEFoam.cxx:1851
 PDEFoam.cxx:1852
 PDEFoam.cxx:1853
 PDEFoam.cxx:1854
 PDEFoam.cxx:1855
 PDEFoam.cxx:1856
 PDEFoam.cxx:1857
 PDEFoam.cxx:1858
 PDEFoam.cxx:1859
 PDEFoam.cxx:1860
 PDEFoam.cxx:1861
 PDEFoam.cxx:1862
 PDEFoam.cxx:1863
 PDEFoam.cxx:1864
 PDEFoam.cxx:1865
 PDEFoam.cxx:1866
 PDEFoam.cxx:1867
 PDEFoam.cxx:1868
 PDEFoam.cxx:1869
 PDEFoam.cxx:1870
 PDEFoam.cxx:1871
 PDEFoam.cxx:1872
 PDEFoam.cxx:1873
 PDEFoam.cxx:1874
 PDEFoam.cxx:1875
 PDEFoam.cxx:1876
 PDEFoam.cxx:1877
 PDEFoam.cxx:1878
 PDEFoam.cxx:1879
 PDEFoam.cxx:1880
 PDEFoam.cxx:1881
 PDEFoam.cxx:1882
 PDEFoam.cxx:1883
 PDEFoam.cxx:1884
 PDEFoam.cxx:1885
 PDEFoam.cxx:1886
 PDEFoam.cxx:1887
 PDEFoam.cxx:1888
 PDEFoam.cxx:1889
 PDEFoam.cxx:1890
 PDEFoam.cxx:1891
 PDEFoam.cxx:1892
 PDEFoam.cxx:1893
 PDEFoam.cxx:1894
 PDEFoam.cxx:1895
 PDEFoam.cxx:1896
 PDEFoam.cxx:1897
 PDEFoam.cxx:1898
 PDEFoam.cxx:1899
 PDEFoam.cxx:1900
 PDEFoam.cxx:1901
 PDEFoam.cxx:1902
 PDEFoam.cxx:1903
 PDEFoam.cxx:1904
 PDEFoam.cxx:1905
 PDEFoam.cxx:1906
 PDEFoam.cxx:1907
 PDEFoam.cxx:1908
 PDEFoam.cxx:1909
 PDEFoam.cxx:1910
 PDEFoam.cxx:1911
 PDEFoam.cxx:1912
 PDEFoam.cxx:1913
 PDEFoam.cxx:1914
 PDEFoam.cxx:1915
 PDEFoam.cxx:1916
 PDEFoam.cxx:1917
 PDEFoam.cxx:1918
 PDEFoam.cxx:1919
 PDEFoam.cxx:1920
 PDEFoam.cxx:1921
 PDEFoam.cxx:1922
 PDEFoam.cxx:1923
 PDEFoam.cxx:1924
 PDEFoam.cxx:1925
 PDEFoam.cxx:1926
 PDEFoam.cxx:1927
 PDEFoam.cxx:1928
 PDEFoam.cxx:1929
 PDEFoam.cxx:1930
 PDEFoam.cxx:1931
 PDEFoam.cxx:1932
 PDEFoam.cxx:1933
 PDEFoam.cxx:1934
 PDEFoam.cxx:1935
 PDEFoam.cxx:1936
 PDEFoam.cxx:1937
 PDEFoam.cxx:1938
 PDEFoam.cxx:1939
 PDEFoam.cxx:1940
 PDEFoam.cxx:1941
 PDEFoam.cxx:1942
 PDEFoam.cxx:1943
 PDEFoam.cxx:1944
 PDEFoam.cxx:1945
 PDEFoam.cxx:1946
 PDEFoam.cxx:1947
 PDEFoam.cxx:1948
 PDEFoam.cxx:1949
 PDEFoam.cxx:1950
 PDEFoam.cxx:1951
 PDEFoam.cxx:1952
 PDEFoam.cxx:1953
 PDEFoam.cxx:1954
 PDEFoam.cxx:1955
 PDEFoam.cxx:1956
 PDEFoam.cxx:1957
 PDEFoam.cxx:1958
 PDEFoam.cxx:1959
 PDEFoam.cxx:1960
 PDEFoam.cxx:1961
 PDEFoam.cxx:1962
 PDEFoam.cxx:1963
 PDEFoam.cxx:1964
 PDEFoam.cxx:1965
 PDEFoam.cxx:1966
 PDEFoam.cxx:1967
 PDEFoam.cxx:1968
 PDEFoam.cxx:1969
 PDEFoam.cxx:1970
 PDEFoam.cxx:1971
 PDEFoam.cxx:1972
 PDEFoam.cxx:1973
 PDEFoam.cxx:1974
 PDEFoam.cxx:1975
 PDEFoam.cxx:1976
 PDEFoam.cxx:1977
 PDEFoam.cxx:1978
 PDEFoam.cxx:1979
 PDEFoam.cxx:1980
 PDEFoam.cxx:1981
 PDEFoam.cxx:1982
 PDEFoam.cxx:1983
 PDEFoam.cxx:1984
 PDEFoam.cxx:1985
 PDEFoam.cxx:1986
 PDEFoam.cxx:1987
 PDEFoam.cxx:1988
 PDEFoam.cxx:1989
 PDEFoam.cxx:1990
 PDEFoam.cxx:1991
 PDEFoam.cxx:1992
 PDEFoam.cxx:1993
 PDEFoam.cxx:1994
 PDEFoam.cxx:1995
 PDEFoam.cxx:1996
 PDEFoam.cxx:1997
 PDEFoam.cxx:1998
 PDEFoam.cxx:1999
 PDEFoam.cxx:2000
 PDEFoam.cxx:2001
 PDEFoam.cxx:2002
 PDEFoam.cxx:2003
 PDEFoam.cxx:2004
 PDEFoam.cxx:2005
 PDEFoam.cxx:2006
 PDEFoam.cxx:2007
 PDEFoam.cxx:2008
 PDEFoam.cxx:2009
 PDEFoam.cxx:2010
 PDEFoam.cxx:2011
 PDEFoam.cxx:2012
 PDEFoam.cxx:2013
 PDEFoam.cxx:2014
 PDEFoam.cxx:2015
 PDEFoam.cxx:2016
 PDEFoam.cxx:2017
 PDEFoam.cxx:2018
 PDEFoam.cxx:2019
 PDEFoam.cxx:2020
 PDEFoam.cxx:2021
 PDEFoam.cxx:2022
 PDEFoam.cxx:2023
 PDEFoam.cxx:2024
 PDEFoam.cxx:2025
 PDEFoam.cxx:2026
 PDEFoam.cxx:2027
 PDEFoam.cxx:2028
 PDEFoam.cxx:2029
 PDEFoam.cxx:2030
 PDEFoam.cxx:2031
 PDEFoam.cxx:2032
 PDEFoam.cxx:2033
 PDEFoam.cxx:2034
 PDEFoam.cxx:2035
 PDEFoam.cxx:2036
 PDEFoam.cxx:2037
 PDEFoam.cxx:2038
 PDEFoam.cxx:2039
 PDEFoam.cxx:2040
 PDEFoam.cxx:2041
 PDEFoam.cxx:2042
 PDEFoam.cxx:2043
 PDEFoam.cxx:2044
 PDEFoam.cxx:2045
 PDEFoam.cxx:2046
 PDEFoam.cxx:2047
 PDEFoam.cxx:2048
 PDEFoam.cxx:2049
 PDEFoam.cxx:2050
 PDEFoam.cxx:2051
 PDEFoam.cxx:2052
 PDEFoam.cxx:2053
 PDEFoam.cxx:2054
 PDEFoam.cxx:2055
 PDEFoam.cxx:2056
 PDEFoam.cxx:2057
 PDEFoam.cxx:2058
 PDEFoam.cxx:2059
 PDEFoam.cxx:2060
 PDEFoam.cxx:2061
 PDEFoam.cxx:2062
 PDEFoam.cxx:2063
 PDEFoam.cxx:2064
 PDEFoam.cxx:2065
 PDEFoam.cxx:2066
 PDEFoam.cxx:2067
 PDEFoam.cxx:2068
 PDEFoam.cxx:2069
 PDEFoam.cxx:2070
 PDEFoam.cxx:2071
 PDEFoam.cxx:2072
 PDEFoam.cxx:2073
 PDEFoam.cxx:2074
 PDEFoam.cxx:2075
 PDEFoam.cxx:2076
 PDEFoam.cxx:2077
 PDEFoam.cxx:2078
 PDEFoam.cxx:2079
 PDEFoam.cxx:2080
 PDEFoam.cxx:2081
 PDEFoam.cxx:2082
 PDEFoam.cxx:2083
 PDEFoam.cxx:2084
 PDEFoam.cxx:2085
 PDEFoam.cxx:2086
 PDEFoam.cxx:2087
 PDEFoam.cxx:2088
 PDEFoam.cxx:2089
 PDEFoam.cxx:2090
 PDEFoam.cxx:2091
 PDEFoam.cxx:2092
 PDEFoam.cxx:2093
 PDEFoam.cxx:2094
 PDEFoam.cxx:2095
 PDEFoam.cxx:2096
 PDEFoam.cxx:2097
 PDEFoam.cxx:2098
 PDEFoam.cxx:2099
 PDEFoam.cxx:2100
 PDEFoam.cxx:2101
 PDEFoam.cxx:2102
 PDEFoam.cxx:2103
 PDEFoam.cxx:2104
 PDEFoam.cxx:2105
 PDEFoam.cxx:2106
 PDEFoam.cxx:2107
 PDEFoam.cxx:2108
 PDEFoam.cxx:2109
 PDEFoam.cxx:2110
 PDEFoam.cxx:2111
 PDEFoam.cxx:2112
 PDEFoam.cxx:2113
 PDEFoam.cxx:2114
 PDEFoam.cxx:2115
 PDEFoam.cxx:2116
 PDEFoam.cxx:2117
 PDEFoam.cxx:2118
 PDEFoam.cxx:2119
 PDEFoam.cxx:2120
 PDEFoam.cxx:2121
 PDEFoam.cxx:2122
 PDEFoam.cxx:2123
 PDEFoam.cxx:2124
 PDEFoam.cxx:2125
 PDEFoam.cxx:2126
 PDEFoam.cxx:2127
 PDEFoam.cxx:2128
 PDEFoam.cxx:2129
 PDEFoam.cxx:2130
 PDEFoam.cxx:2131
 PDEFoam.cxx:2132
 PDEFoam.cxx:2133
 PDEFoam.cxx:2134
 PDEFoam.cxx:2135
 PDEFoam.cxx:2136
 PDEFoam.cxx:2137
 PDEFoam.cxx:2138
 PDEFoam.cxx:2139
 PDEFoam.cxx:2140
 PDEFoam.cxx:2141
 PDEFoam.cxx:2142
 PDEFoam.cxx:2143
 PDEFoam.cxx:2144
 PDEFoam.cxx:2145
 PDEFoam.cxx:2146
 PDEFoam.cxx:2147
 PDEFoam.cxx:2148
 PDEFoam.cxx:2149
 PDEFoam.cxx:2150
 PDEFoam.cxx:2151
 PDEFoam.cxx:2152
 PDEFoam.cxx:2153
 PDEFoam.cxx:2154
 PDEFoam.cxx:2155
 PDEFoam.cxx:2156
 PDEFoam.cxx:2157
 PDEFoam.cxx:2158
 PDEFoam.cxx:2159
 PDEFoam.cxx:2160
 PDEFoam.cxx:2161
 PDEFoam.cxx:2162
 PDEFoam.cxx:2163
 PDEFoam.cxx:2164
 PDEFoam.cxx:2165
 PDEFoam.cxx:2166
 PDEFoam.cxx:2167
 PDEFoam.cxx:2168
 PDEFoam.cxx:2169
 PDEFoam.cxx:2170
 PDEFoam.cxx:2171
 PDEFoam.cxx:2172
 PDEFoam.cxx:2173
 PDEFoam.cxx:2174
 PDEFoam.cxx:2175
 PDEFoam.cxx:2176
 PDEFoam.cxx:2177
 PDEFoam.cxx:2178
 PDEFoam.cxx:2179
 PDEFoam.cxx:2180
 PDEFoam.cxx:2181
 PDEFoam.cxx:2182
 PDEFoam.cxx:2183
 PDEFoam.cxx:2184
 PDEFoam.cxx:2185
 PDEFoam.cxx:2186
 PDEFoam.cxx:2187
 PDEFoam.cxx:2188
 PDEFoam.cxx:2189
 PDEFoam.cxx:2190
 PDEFoam.cxx:2191
 PDEFoam.cxx:2192
 PDEFoam.cxx:2193
 PDEFoam.cxx:2194
 PDEFoam.cxx:2195
 PDEFoam.cxx:2196
 PDEFoam.cxx:2197
 PDEFoam.cxx:2198
 PDEFoam.cxx:2199
 PDEFoam.cxx:2200
 PDEFoam.cxx:2201
 PDEFoam.cxx:2202
 PDEFoam.cxx:2203
 PDEFoam.cxx:2204
 PDEFoam.cxx:2205
 PDEFoam.cxx:2206
 PDEFoam.cxx:2207
 PDEFoam.cxx:2208
 PDEFoam.cxx:2209
 PDEFoam.cxx:2210
 PDEFoam.cxx:2211
 PDEFoam.cxx:2212
 PDEFoam.cxx:2213
 PDEFoam.cxx:2214
 PDEFoam.cxx:2215
 PDEFoam.cxx:2216
 PDEFoam.cxx:2217
 PDEFoam.cxx:2218
 PDEFoam.cxx:2219
 PDEFoam.cxx:2220
 PDEFoam.cxx:2221
 PDEFoam.cxx:2222
 PDEFoam.cxx:2223
 PDEFoam.cxx:2224
 PDEFoam.cxx:2225
 PDEFoam.cxx:2226
 PDEFoam.cxx:2227
 PDEFoam.cxx:2228
 PDEFoam.cxx:2229
 PDEFoam.cxx:2230
 PDEFoam.cxx:2231
 PDEFoam.cxx:2232
 PDEFoam.cxx:2233
 PDEFoam.cxx:2234
 PDEFoam.cxx:2235
 PDEFoam.cxx:2236
 PDEFoam.cxx:2237
 PDEFoam.cxx:2238
 PDEFoam.cxx:2239
 PDEFoam.cxx:2240
 PDEFoam.cxx:2241
 PDEFoam.cxx:2242
 PDEFoam.cxx:2243
 PDEFoam.cxx:2244
 PDEFoam.cxx:2245
 PDEFoam.cxx:2246
 PDEFoam.cxx:2247
 PDEFoam.cxx:2248
 PDEFoam.cxx:2249
 PDEFoam.cxx:2250
 PDEFoam.cxx:2251
 PDEFoam.cxx:2252
 PDEFoam.cxx:2253
 PDEFoam.cxx:2254
 PDEFoam.cxx:2255
 PDEFoam.cxx:2256
 PDEFoam.cxx:2257
 PDEFoam.cxx:2258
 PDEFoam.cxx:2259
 PDEFoam.cxx:2260
 PDEFoam.cxx:2261
 PDEFoam.cxx:2262
 PDEFoam.cxx:2263
 PDEFoam.cxx:2264
 PDEFoam.cxx:2265
 PDEFoam.cxx:2266
 PDEFoam.cxx:2267
 PDEFoam.cxx:2268
 PDEFoam.cxx:2269
 PDEFoam.cxx:2270
 PDEFoam.cxx:2271
 PDEFoam.cxx:2272
 PDEFoam.cxx:2273
 PDEFoam.cxx:2274
 PDEFoam.cxx:2275
 PDEFoam.cxx:2276
 PDEFoam.cxx:2277
 PDEFoam.cxx:2278
 PDEFoam.cxx:2279
 PDEFoam.cxx:2280
 PDEFoam.cxx:2281
 PDEFoam.cxx:2282
 PDEFoam.cxx:2283
 PDEFoam.cxx:2284
 PDEFoam.cxx:2285
 PDEFoam.cxx:2286
 PDEFoam.cxx:2287
 PDEFoam.cxx:2288
 PDEFoam.cxx:2289
 PDEFoam.cxx:2290
 PDEFoam.cxx:2291
 PDEFoam.cxx:2292
 PDEFoam.cxx:2293
 PDEFoam.cxx:2294
 PDEFoam.cxx:2295
 PDEFoam.cxx:2296
 PDEFoam.cxx:2297
 PDEFoam.cxx:2298
 PDEFoam.cxx:2299
 PDEFoam.cxx:2300
 PDEFoam.cxx:2301
 PDEFoam.cxx:2302
 PDEFoam.cxx:2303
 PDEFoam.cxx:2304
 PDEFoam.cxx:2305
 PDEFoam.cxx:2306
 PDEFoam.cxx:2307
 PDEFoam.cxx:2308
 PDEFoam.cxx:2309
 PDEFoam.cxx:2310
 PDEFoam.cxx:2311
 PDEFoam.cxx:2312
 PDEFoam.cxx:2313
 PDEFoam.cxx:2314
 PDEFoam.cxx:2315
 PDEFoam.cxx:2316
 PDEFoam.cxx:2317
 PDEFoam.cxx:2318
 PDEFoam.cxx:2319
 PDEFoam.cxx:2320
 PDEFoam.cxx:2321
 PDEFoam.cxx:2322
 PDEFoam.cxx:2323
 PDEFoam.cxx:2324
 PDEFoam.cxx:2325
 PDEFoam.cxx:2326
 PDEFoam.cxx:2327
 PDEFoam.cxx:2328
 PDEFoam.cxx:2329
 PDEFoam.cxx:2330
 PDEFoam.cxx:2331
 PDEFoam.cxx:2332
 PDEFoam.cxx:2333
 PDEFoam.cxx:2334
 PDEFoam.cxx:2335
 PDEFoam.cxx:2336
 PDEFoam.cxx:2337
 PDEFoam.cxx:2338
 PDEFoam.cxx:2339
 PDEFoam.cxx:2340
 PDEFoam.cxx:2341
 PDEFoam.cxx:2342
 PDEFoam.cxx:2343
 PDEFoam.cxx:2344
 PDEFoam.cxx:2345
 PDEFoam.cxx:2346
 PDEFoam.cxx:2347
 PDEFoam.cxx:2348
 PDEFoam.cxx:2349
 PDEFoam.cxx:2350
 PDEFoam.cxx:2351
 PDEFoam.cxx:2352
 PDEFoam.cxx:2353
 PDEFoam.cxx:2354
 PDEFoam.cxx:2355
 PDEFoam.cxx:2356
 PDEFoam.cxx:2357
 PDEFoam.cxx:2358
 PDEFoam.cxx:2359
 PDEFoam.cxx:2360
 PDEFoam.cxx:2361
 PDEFoam.cxx:2362
 PDEFoam.cxx:2363
 PDEFoam.cxx:2364
 PDEFoam.cxx:2365
 PDEFoam.cxx:2366
 PDEFoam.cxx:2367
 PDEFoam.cxx:2368
 PDEFoam.cxx:2369
 PDEFoam.cxx:2370
 PDEFoam.cxx:2371
 PDEFoam.cxx:2372
 PDEFoam.cxx:2373
 PDEFoam.cxx:2374
 PDEFoam.cxx:2375
 PDEFoam.cxx:2376
 PDEFoam.cxx:2377
 PDEFoam.cxx:2378
 PDEFoam.cxx:2379
 PDEFoam.cxx:2380
 PDEFoam.cxx:2381
 PDEFoam.cxx:2382
 PDEFoam.cxx:2383
 PDEFoam.cxx:2384
 PDEFoam.cxx:2385
 PDEFoam.cxx:2386
 PDEFoam.cxx:2387
 PDEFoam.cxx:2388
 PDEFoam.cxx:2389
 PDEFoam.cxx:2390
 PDEFoam.cxx:2391
 PDEFoam.cxx:2392
 PDEFoam.cxx:2393
 PDEFoam.cxx:2394
 PDEFoam.cxx:2395
 PDEFoam.cxx:2396
 PDEFoam.cxx:2397
 PDEFoam.cxx:2398
 PDEFoam.cxx:2399
 PDEFoam.cxx:2400
 PDEFoam.cxx:2401
 PDEFoam.cxx:2402
 PDEFoam.cxx:2403
 PDEFoam.cxx:2404
 PDEFoam.cxx:2405
 PDEFoam.cxx:2406
 PDEFoam.cxx:2407
 PDEFoam.cxx:2408
 PDEFoam.cxx:2409
 PDEFoam.cxx:2410
 PDEFoam.cxx:2411
 PDEFoam.cxx:2412
 PDEFoam.cxx:2413
 PDEFoam.cxx:2414
 PDEFoam.cxx:2415
 PDEFoam.cxx:2416
 PDEFoam.cxx:2417
 PDEFoam.cxx:2418
 PDEFoam.cxx:2419
 PDEFoam.cxx:2420
 PDEFoam.cxx:2421
 PDEFoam.cxx:2422
 PDEFoam.cxx:2423
 PDEFoam.cxx:2424
 PDEFoam.cxx:2425
 PDEFoam.cxx:2426
 PDEFoam.cxx:2427
 PDEFoam.cxx:2428
 PDEFoam.cxx:2429
 PDEFoam.cxx:2430
 PDEFoam.cxx:2431
 PDEFoam.cxx:2432
 PDEFoam.cxx:2433
 PDEFoam.cxx:2434
 PDEFoam.cxx:2435
 PDEFoam.cxx:2436
 PDEFoam.cxx:2437
 PDEFoam.cxx:2438
 PDEFoam.cxx:2439
 PDEFoam.cxx:2440
 PDEFoam.cxx:2441
 PDEFoam.cxx:2442
 PDEFoam.cxx:2443
 PDEFoam.cxx:2444
 PDEFoam.cxx:2445
 PDEFoam.cxx:2446
 PDEFoam.cxx:2447
 PDEFoam.cxx:2448
 PDEFoam.cxx:2449
 PDEFoam.cxx:2450
 PDEFoam.cxx:2451
 PDEFoam.cxx:2452
 PDEFoam.cxx:2453
 PDEFoam.cxx:2454
 PDEFoam.cxx:2455
 PDEFoam.cxx:2456
 PDEFoam.cxx:2457
 PDEFoam.cxx:2458
 PDEFoam.cxx:2459
 PDEFoam.cxx:2460
 PDEFoam.cxx:2461
 PDEFoam.cxx:2462
 PDEFoam.cxx:2463
 PDEFoam.cxx:2464
 PDEFoam.cxx:2465
 PDEFoam.cxx:2466
 PDEFoam.cxx:2467
 PDEFoam.cxx:2468
 PDEFoam.cxx:2469
 PDEFoam.cxx:2470
 PDEFoam.cxx:2471
 PDEFoam.cxx:2472
 PDEFoam.cxx:2473
 PDEFoam.cxx:2474
 PDEFoam.cxx:2475
 PDEFoam.cxx:2476
 PDEFoam.cxx:2477
 PDEFoam.cxx:2478
 PDEFoam.cxx:2479
 PDEFoam.cxx:2480
 PDEFoam.cxx:2481
 PDEFoam.cxx:2482
 PDEFoam.cxx:2483
 PDEFoam.cxx:2484
 PDEFoam.cxx:2485
 PDEFoam.cxx:2486
 PDEFoam.cxx:2487
 PDEFoam.cxx:2488
 PDEFoam.cxx:2489
 PDEFoam.cxx:2490
 PDEFoam.cxx:2491
 PDEFoam.cxx:2492
 PDEFoam.cxx:2493
 PDEFoam.cxx:2494
 PDEFoam.cxx:2495
 PDEFoam.cxx:2496
 PDEFoam.cxx:2497
 PDEFoam.cxx:2498
 PDEFoam.cxx:2499
 PDEFoam.cxx:2500
 PDEFoam.cxx:2501
 PDEFoam.cxx:2502
 PDEFoam.cxx:2503
 PDEFoam.cxx:2504
 PDEFoam.cxx:2505
 PDEFoam.cxx:2506
 PDEFoam.cxx:2507
 PDEFoam.cxx:2508
 PDEFoam.cxx:2509
 PDEFoam.cxx:2510
 PDEFoam.cxx:2511
 PDEFoam.cxx:2512
 PDEFoam.cxx:2513
 PDEFoam.cxx:2514
 PDEFoam.cxx:2515
 PDEFoam.cxx:2516
 PDEFoam.cxx:2517
 PDEFoam.cxx:2518
 PDEFoam.cxx:2519
 PDEFoam.cxx:2520
 PDEFoam.cxx:2521
 PDEFoam.cxx:2522
 PDEFoam.cxx:2523
 PDEFoam.cxx:2524
 PDEFoam.cxx:2525
 PDEFoam.cxx:2526
 PDEFoam.cxx:2527
 PDEFoam.cxx:2528
 PDEFoam.cxx:2529
 PDEFoam.cxx:2530
 PDEFoam.cxx:2531
 PDEFoam.cxx:2532
 PDEFoam.cxx:2533
 PDEFoam.cxx:2534
 PDEFoam.cxx:2535
 PDEFoam.cxx:2536
 PDEFoam.cxx:2537
 PDEFoam.cxx:2538
 PDEFoam.cxx:2539
 PDEFoam.cxx:2540
 PDEFoam.cxx:2541
 PDEFoam.cxx:2542
 PDEFoam.cxx:2543
 PDEFoam.cxx:2544
 PDEFoam.cxx:2545
 PDEFoam.cxx:2546
 PDEFoam.cxx:2547
 PDEFoam.cxx:2548
 PDEFoam.cxx:2549
 PDEFoam.cxx:2550
 PDEFoam.cxx:2551
 PDEFoam.cxx:2552
 PDEFoam.cxx:2553
 PDEFoam.cxx:2554
 PDEFoam.cxx:2555
 PDEFoam.cxx:2556
 PDEFoam.cxx:2557
 PDEFoam.cxx:2558
 PDEFoam.cxx:2559
 PDEFoam.cxx:2560
 PDEFoam.cxx:2561
 PDEFoam.cxx:2562
 PDEFoam.cxx:2563
 PDEFoam.cxx:2564
 PDEFoam.cxx:2565
 PDEFoam.cxx:2566
 PDEFoam.cxx:2567
 PDEFoam.cxx:2568
 PDEFoam.cxx:2569
 PDEFoam.cxx:2570
 PDEFoam.cxx:2571
 PDEFoam.cxx:2572
 PDEFoam.cxx:2573
 PDEFoam.cxx:2574
 PDEFoam.cxx:2575
 PDEFoam.cxx:2576
 PDEFoam.cxx:2577
 PDEFoam.cxx:2578
 PDEFoam.cxx:2579
 PDEFoam.cxx:2580
 PDEFoam.cxx:2581
 PDEFoam.cxx:2582
 PDEFoam.cxx:2583
 PDEFoam.cxx:2584
 PDEFoam.cxx:2585
 PDEFoam.cxx:2586
 PDEFoam.cxx:2587
 PDEFoam.cxx:2588
 PDEFoam.cxx:2589
 PDEFoam.cxx:2590
 PDEFoam.cxx:2591
 PDEFoam.cxx:2592
 PDEFoam.cxx:2593
 PDEFoam.cxx:2594
 PDEFoam.cxx:2595
 PDEFoam.cxx:2596
 PDEFoam.cxx:2597
 PDEFoam.cxx:2598
 PDEFoam.cxx:2599
 PDEFoam.cxx:2600
 PDEFoam.cxx:2601
 PDEFoam.cxx:2602
 PDEFoam.cxx:2603
 PDEFoam.cxx:2604
 PDEFoam.cxx:2605
 PDEFoam.cxx:2606
 PDEFoam.cxx:2607
 PDEFoam.cxx:2608
 PDEFoam.cxx:2609
 PDEFoam.cxx:2610
 PDEFoam.cxx:2611
 PDEFoam.cxx:2612
 PDEFoam.cxx:2613
 PDEFoam.cxx:2614
 PDEFoam.cxx:2615
 PDEFoam.cxx:2616
 PDEFoam.cxx:2617
 PDEFoam.cxx:2618
 PDEFoam.cxx:2619
 PDEFoam.cxx:2620
 PDEFoam.cxx:2621
 PDEFoam.cxx:2622
 PDEFoam.cxx:2623
 PDEFoam.cxx:2624
 PDEFoam.cxx:2625
 PDEFoam.cxx:2626
 PDEFoam.cxx:2627
 PDEFoam.cxx:2628
 PDEFoam.cxx:2629
 PDEFoam.cxx:2630
 PDEFoam.cxx:2631
 PDEFoam.cxx:2632
 PDEFoam.cxx:2633
 PDEFoam.cxx:2634
 PDEFoam.cxx:2635
 PDEFoam.cxx:2636
 PDEFoam.cxx:2637
 PDEFoam.cxx:2638
 PDEFoam.cxx:2639
 PDEFoam.cxx:2640
 PDEFoam.cxx:2641
 PDEFoam.cxx:2642
 PDEFoam.cxx:2643
 PDEFoam.cxx:2644
 PDEFoam.cxx:2645
 PDEFoam.cxx:2646
 PDEFoam.cxx:2647
 PDEFoam.cxx:2648
 PDEFoam.cxx:2649
 PDEFoam.cxx:2650
 PDEFoam.cxx:2651
 PDEFoam.cxx:2652
 PDEFoam.cxx:2653
 PDEFoam.cxx:2654
 PDEFoam.cxx:2655
 PDEFoam.cxx:2656
 PDEFoam.cxx:2657
 PDEFoam.cxx:2658
 PDEFoam.cxx:2659
 PDEFoam.cxx:2660
 PDEFoam.cxx:2661
 PDEFoam.cxx:2662
 PDEFoam.cxx:2663
 PDEFoam.cxx:2664
 PDEFoam.cxx:2665
 PDEFoam.cxx:2666
 PDEFoam.cxx:2667
 PDEFoam.cxx:2668
 PDEFoam.cxx:2669
 PDEFoam.cxx:2670
 PDEFoam.cxx:2671
 PDEFoam.cxx:2672
 PDEFoam.cxx:2673
 PDEFoam.cxx:2674
 PDEFoam.cxx:2675
 PDEFoam.cxx:2676
 PDEFoam.cxx:2677
 PDEFoam.cxx:2678
 PDEFoam.cxx:2679
 PDEFoam.cxx:2680
 PDEFoam.cxx:2681
 PDEFoam.cxx:2682
 PDEFoam.cxx:2683
 PDEFoam.cxx:2684
 PDEFoam.cxx:2685
 PDEFoam.cxx:2686
 PDEFoam.cxx:2687
 PDEFoam.cxx:2688
 PDEFoam.cxx:2689
 PDEFoam.cxx:2690
 PDEFoam.cxx:2691
 PDEFoam.cxx:2692
 PDEFoam.cxx:2693
 PDEFoam.cxx:2694
 PDEFoam.cxx:2695
 PDEFoam.cxx:2696
 PDEFoam.cxx:2697
 PDEFoam.cxx:2698
 PDEFoam.cxx:2699
 PDEFoam.cxx:2700
 PDEFoam.cxx:2701
 PDEFoam.cxx:2702
 PDEFoam.cxx:2703
 PDEFoam.cxx:2704
 PDEFoam.cxx:2705
 PDEFoam.cxx:2706
 PDEFoam.cxx:2707
 PDEFoam.cxx:2708
 PDEFoam.cxx:2709
 PDEFoam.cxx:2710
 PDEFoam.cxx:2711
 PDEFoam.cxx:2712
 PDEFoam.cxx:2713
 PDEFoam.cxx:2714
 PDEFoam.cxx:2715
 PDEFoam.cxx:2716
 PDEFoam.cxx:2717
 PDEFoam.cxx:2718
 PDEFoam.cxx:2719
 PDEFoam.cxx:2720
 PDEFoam.cxx:2721
 PDEFoam.cxx:2722
 PDEFoam.cxx:2723
 PDEFoam.cxx:2724
 PDEFoam.cxx:2725
 PDEFoam.cxx:2726
 PDEFoam.cxx:2727
 PDEFoam.cxx:2728
 PDEFoam.cxx:2729
 PDEFoam.cxx:2730
 PDEFoam.cxx:2731
 PDEFoam.cxx:2732
 PDEFoam.cxx:2733
 PDEFoam.cxx:2734
 PDEFoam.cxx:2735
 PDEFoam.cxx:2736
 PDEFoam.cxx:2737
 PDEFoam.cxx:2738
 PDEFoam.cxx:2739
 PDEFoam.cxx:2740
 PDEFoam.cxx:2741
 PDEFoam.cxx:2742
 PDEFoam.cxx:2743
 PDEFoam.cxx:2744
 PDEFoam.cxx:2745
 PDEFoam.cxx:2746
 PDEFoam.cxx:2747
 PDEFoam.cxx:2748
 PDEFoam.cxx:2749
 PDEFoam.cxx:2750
 PDEFoam.cxx:2751
 PDEFoam.cxx:2752
 PDEFoam.cxx:2753
 PDEFoam.cxx:2754
 PDEFoam.cxx:2755
 PDEFoam.cxx:2756
 PDEFoam.cxx:2757
 PDEFoam.cxx:2758
 PDEFoam.cxx:2759
 PDEFoam.cxx:2760
 PDEFoam.cxx:2761
 PDEFoam.cxx:2762
 PDEFoam.cxx:2763
 PDEFoam.cxx:2764
 PDEFoam.cxx:2765
 PDEFoam.cxx:2766
 PDEFoam.cxx:2767
 PDEFoam.cxx:2768
 PDEFoam.cxx:2769
 PDEFoam.cxx:2770
 PDEFoam.cxx:2771
 PDEFoam.cxx:2772
 PDEFoam.cxx:2773
 PDEFoam.cxx:2774
 PDEFoam.cxx:2775
 PDEFoam.cxx:2776
 PDEFoam.cxx:2777
 PDEFoam.cxx:2778
 PDEFoam.cxx:2779
 PDEFoam.cxx:2780
 PDEFoam.cxx:2781
 PDEFoam.cxx:2782
 PDEFoam.cxx:2783
 PDEFoam.cxx:2784
 PDEFoam.cxx:2785
 PDEFoam.cxx:2786
 PDEFoam.cxx:2787
 PDEFoam.cxx:2788
 PDEFoam.cxx:2789
 PDEFoam.cxx:2790
 PDEFoam.cxx:2791
 PDEFoam.cxx:2792
 PDEFoam.cxx:2793
 PDEFoam.cxx:2794
 PDEFoam.cxx:2795
 PDEFoam.cxx:2796
 PDEFoam.cxx:2797
 PDEFoam.cxx:2798
 PDEFoam.cxx:2799
 PDEFoam.cxx:2800
 PDEFoam.cxx:2801
 PDEFoam.cxx:2802
 PDEFoam.cxx:2803
 PDEFoam.cxx:2804
 PDEFoam.cxx:2805
 PDEFoam.cxx:2806
 PDEFoam.cxx:2807
 PDEFoam.cxx:2808
 PDEFoam.cxx:2809
 PDEFoam.cxx:2810
 PDEFoam.cxx:2811
 PDEFoam.cxx:2812
 PDEFoam.cxx:2813
 PDEFoam.cxx:2814
 PDEFoam.cxx:2815
 PDEFoam.cxx:2816
 PDEFoam.cxx:2817
 PDEFoam.cxx:2818
 PDEFoam.cxx:2819
 PDEFoam.cxx:2820
 PDEFoam.cxx:2821
 PDEFoam.cxx:2822
 PDEFoam.cxx:2823
 PDEFoam.cxx:2824
 PDEFoam.cxx:2825
 PDEFoam.cxx:2826
 PDEFoam.cxx:2827
 PDEFoam.cxx:2828
 PDEFoam.cxx:2829
 PDEFoam.cxx:2830
 PDEFoam.cxx:2831
 PDEFoam.cxx:2832
 PDEFoam.cxx:2833
 PDEFoam.cxx:2834
 PDEFoam.cxx:2835
 PDEFoam.cxx:2836
 PDEFoam.cxx:2837
 PDEFoam.cxx:2838
 PDEFoam.cxx:2839
 PDEFoam.cxx:2840
 PDEFoam.cxx:2841
 PDEFoam.cxx:2842
 PDEFoam.cxx:2843
 PDEFoam.cxx:2844
 PDEFoam.cxx:2845
 PDEFoam.cxx:2846
 PDEFoam.cxx:2847
 PDEFoam.cxx:2848
 PDEFoam.cxx:2849
 PDEFoam.cxx:2850
 PDEFoam.cxx:2851
 PDEFoam.cxx:2852
 PDEFoam.cxx:2853
 PDEFoam.cxx:2854
 PDEFoam.cxx:2855
 PDEFoam.cxx:2856
 PDEFoam.cxx:2857
 PDEFoam.cxx:2858
 PDEFoam.cxx:2859
 PDEFoam.cxx:2860
 PDEFoam.cxx:2861
 PDEFoam.cxx:2862
 PDEFoam.cxx:2863
 PDEFoam.cxx:2864
 PDEFoam.cxx:2865
 PDEFoam.cxx:2866
 PDEFoam.cxx:2867
 PDEFoam.cxx:2868
 PDEFoam.cxx:2869
 PDEFoam.cxx:2870
 PDEFoam.cxx:2871
 PDEFoam.cxx:2872
 PDEFoam.cxx:2873
 PDEFoam.cxx:2874
 PDEFoam.cxx:2875
 PDEFoam.cxx:2876
 PDEFoam.cxx:2877
 PDEFoam.cxx:2878
 PDEFoam.cxx:2879
 PDEFoam.cxx:2880
 PDEFoam.cxx:2881
 PDEFoam.cxx:2882
 PDEFoam.cxx:2883
 PDEFoam.cxx:2884
 PDEFoam.cxx:2885
 PDEFoam.cxx:2886
 PDEFoam.cxx:2887
 PDEFoam.cxx:2888
 PDEFoam.cxx:2889
 PDEFoam.cxx:2890
 PDEFoam.cxx:2891
 PDEFoam.cxx:2892
 PDEFoam.cxx:2893
 PDEFoam.cxx:2894
 PDEFoam.cxx:2895
 PDEFoam.cxx:2896
 PDEFoam.cxx:2897
 PDEFoam.cxx:2898
 PDEFoam.cxx:2899
 PDEFoam.cxx:2900
 PDEFoam.cxx:2901
 PDEFoam.cxx:2902
 PDEFoam.cxx:2903
 PDEFoam.cxx:2904
 PDEFoam.cxx:2905
 PDEFoam.cxx:2906
 PDEFoam.cxx:2907
 PDEFoam.cxx:2908
 PDEFoam.cxx:2909
 PDEFoam.cxx:2910
 PDEFoam.cxx:2911
 PDEFoam.cxx:2912
 PDEFoam.cxx:2913
 PDEFoam.cxx:2914
 PDEFoam.cxx:2915
 PDEFoam.cxx:2916
 PDEFoam.cxx:2917
 PDEFoam.cxx:2918
 PDEFoam.cxx:2919
 PDEFoam.cxx:2920
 PDEFoam.cxx:2921
 PDEFoam.cxx:2922
 PDEFoam.cxx:2923
 PDEFoam.cxx:2924
 PDEFoam.cxx:2925
 PDEFoam.cxx:2926
 PDEFoam.cxx:2927
 PDEFoam.cxx:2928
 PDEFoam.cxx:2929
 PDEFoam.cxx:2930
 PDEFoam.cxx:2931
 PDEFoam.cxx:2932
 PDEFoam.cxx:2933
 PDEFoam.cxx:2934
 PDEFoam.cxx:2935
 PDEFoam.cxx:2936
 PDEFoam.cxx:2937
 PDEFoam.cxx:2938
 PDEFoam.cxx:2939
 PDEFoam.cxx:2940
 PDEFoam.cxx:2941
 PDEFoam.cxx:2942
 PDEFoam.cxx:2943
 PDEFoam.cxx:2944
 PDEFoam.cxx:2945
 PDEFoam.cxx:2946
 PDEFoam.cxx:2947
 PDEFoam.cxx:2948
 PDEFoam.cxx:2949
 PDEFoam.cxx:2950
 PDEFoam.cxx:2951
 PDEFoam.cxx:2952
 PDEFoam.cxx:2953
 PDEFoam.cxx:2954
 PDEFoam.cxx:2955
 PDEFoam.cxx:2956
 PDEFoam.cxx:2957
 PDEFoam.cxx:2958
 PDEFoam.cxx:2959
 PDEFoam.cxx:2960
 PDEFoam.cxx:2961
 PDEFoam.cxx:2962
 PDEFoam.cxx:2963
 PDEFoam.cxx:2964
 PDEFoam.cxx:2965
 PDEFoam.cxx:2966
 PDEFoam.cxx:2967
 PDEFoam.cxx:2968
 PDEFoam.cxx:2969
 PDEFoam.cxx:2970
 PDEFoam.cxx:2971
 PDEFoam.cxx:2972
 PDEFoam.cxx:2973
 PDEFoam.cxx:2974
 PDEFoam.cxx:2975
 PDEFoam.cxx:2976
 PDEFoam.cxx:2977
 PDEFoam.cxx:2978
 PDEFoam.cxx:2979
 PDEFoam.cxx:2980
 PDEFoam.cxx:2981
 PDEFoam.cxx:2982
 PDEFoam.cxx:2983
 PDEFoam.cxx:2984
 PDEFoam.cxx:2985
 PDEFoam.cxx:2986
 PDEFoam.cxx:2987
 PDEFoam.cxx:2988
 PDEFoam.cxx:2989
 PDEFoam.cxx:2990
 PDEFoam.cxx:2991
 PDEFoam.cxx:2992
 PDEFoam.cxx:2993
 PDEFoam.cxx:2994
 PDEFoam.cxx:2995
 PDEFoam.cxx:2996
 PDEFoam.cxx:2997
 PDEFoam.cxx:2998
 PDEFoam.cxx:2999
 PDEFoam.cxx:3000
 PDEFoam.cxx:3001
 PDEFoam.cxx:3002
 PDEFoam.cxx:3003
 PDEFoam.cxx:3004
 PDEFoam.cxx:3005
 PDEFoam.cxx:3006
 PDEFoam.cxx:3007
 PDEFoam.cxx:3008
 PDEFoam.cxx:3009
 PDEFoam.cxx:3010
 PDEFoam.cxx:3011
 PDEFoam.cxx:3012
 PDEFoam.cxx:3013
 PDEFoam.cxx:3014
 PDEFoam.cxx:3015
 PDEFoam.cxx:3016
 PDEFoam.cxx:3017
 PDEFoam.cxx:3018
 PDEFoam.cxx:3019
 PDEFoam.cxx:3020
 PDEFoam.cxx:3021
 PDEFoam.cxx:3022
 PDEFoam.cxx:3023
 PDEFoam.cxx:3024
 PDEFoam.cxx:3025
 PDEFoam.cxx:3026
 PDEFoam.cxx:3027
 PDEFoam.cxx:3028
 PDEFoam.cxx:3029
 PDEFoam.cxx:3030
 PDEFoam.cxx:3031
 PDEFoam.cxx:3032
 PDEFoam.cxx:3033
 PDEFoam.cxx:3034
 PDEFoam.cxx:3035
 PDEFoam.cxx:3036
 PDEFoam.cxx:3037
 PDEFoam.cxx:3038
 PDEFoam.cxx:3039
 PDEFoam.cxx:3040
 PDEFoam.cxx:3041
 PDEFoam.cxx:3042
 PDEFoam.cxx:3043
 PDEFoam.cxx:3044
 PDEFoam.cxx:3045
 PDEFoam.cxx:3046
 PDEFoam.cxx:3047
 PDEFoam.cxx:3048
 PDEFoam.cxx:3049
 PDEFoam.cxx:3050
 PDEFoam.cxx:3051
 PDEFoam.cxx:3052
 PDEFoam.cxx:3053
 PDEFoam.cxx:3054
 PDEFoam.cxx:3055
 PDEFoam.cxx:3056
 PDEFoam.cxx:3057
 PDEFoam.cxx:3058
 PDEFoam.cxx:3059
 PDEFoam.cxx:3060
 PDEFoam.cxx:3061
 PDEFoam.cxx:3062
 PDEFoam.cxx:3063
 PDEFoam.cxx:3064
 PDEFoam.cxx:3065
 PDEFoam.cxx:3066
 PDEFoam.cxx:3067
 PDEFoam.cxx:3068
 PDEFoam.cxx:3069
 PDEFoam.cxx:3070
 PDEFoam.cxx:3071
 PDEFoam.cxx:3072
 PDEFoam.cxx:3073
 PDEFoam.cxx:3074
 PDEFoam.cxx:3075
 PDEFoam.cxx:3076
 PDEFoam.cxx:3077
 PDEFoam.cxx:3078
 PDEFoam.cxx:3079
 PDEFoam.cxx:3080
 PDEFoam.cxx:3081
 PDEFoam.cxx:3082
 PDEFoam.cxx:3083
 PDEFoam.cxx:3084
 PDEFoam.cxx:3085
 PDEFoam.cxx:3086
 PDEFoam.cxx:3087
 PDEFoam.cxx:3088
 PDEFoam.cxx:3089
 PDEFoam.cxx:3090
 PDEFoam.cxx:3091
 PDEFoam.cxx:3092
 PDEFoam.cxx:3093
 PDEFoam.cxx:3094
 PDEFoam.cxx:3095
 PDEFoam.cxx:3096
 PDEFoam.cxx:3097
 PDEFoam.cxx:3098
 PDEFoam.cxx:3099
 PDEFoam.cxx:3100
 PDEFoam.cxx:3101
 PDEFoam.cxx:3102
 PDEFoam.cxx:3103
 PDEFoam.cxx:3104
 PDEFoam.cxx:3105
 PDEFoam.cxx:3106
 PDEFoam.cxx:3107
 PDEFoam.cxx:3108
 PDEFoam.cxx:3109
 PDEFoam.cxx:3110
 PDEFoam.cxx:3111
 PDEFoam.cxx:3112
 PDEFoam.cxx:3113
 PDEFoam.cxx:3114
 PDEFoam.cxx:3115
 PDEFoam.cxx:3116
 PDEFoam.cxx:3117
 PDEFoam.cxx:3118
 PDEFoam.cxx:3119
 PDEFoam.cxx:3120
 PDEFoam.cxx:3121
 PDEFoam.cxx:3122
 PDEFoam.cxx:3123
 PDEFoam.cxx:3124
 PDEFoam.cxx:3125
 PDEFoam.cxx:3126
 PDEFoam.cxx:3127
 PDEFoam.cxx:3128
 PDEFoam.cxx:3129
 PDEFoam.cxx:3130
 PDEFoam.cxx:3131
 PDEFoam.cxx:3132
 PDEFoam.cxx:3133
 PDEFoam.cxx:3134
 PDEFoam.cxx:3135
 PDEFoam.cxx:3136
 PDEFoam.cxx:3137
 PDEFoam.cxx:3138
 PDEFoam.cxx:3139
 PDEFoam.cxx:3140
 PDEFoam.cxx:3141
 PDEFoam.cxx:3142
 PDEFoam.cxx:3143
 PDEFoam.cxx:3144
 PDEFoam.cxx:3145
 PDEFoam.cxx:3146
 PDEFoam.cxx:3147
 PDEFoam.cxx:3148
 PDEFoam.cxx:3149
 PDEFoam.cxx:3150
 PDEFoam.cxx:3151
 PDEFoam.cxx:3152
 PDEFoam.cxx:3153
 PDEFoam.cxx:3154
 PDEFoam.cxx:3155
 PDEFoam.cxx:3156
 PDEFoam.cxx:3157
 PDEFoam.cxx:3158
 PDEFoam.cxx:3159
 PDEFoam.cxx:3160
 PDEFoam.cxx:3161
 PDEFoam.cxx:3162
 PDEFoam.cxx:3163
 PDEFoam.cxx:3164
 PDEFoam.cxx:3165
 PDEFoam.cxx:3166
 PDEFoam.cxx:3167
 PDEFoam.cxx:3168
 PDEFoam.cxx:3169
 PDEFoam.cxx:3170
 PDEFoam.cxx:3171
 PDEFoam.cxx:3172
 PDEFoam.cxx:3173
 PDEFoam.cxx:3174
 PDEFoam.cxx:3175
 PDEFoam.cxx:3176
 PDEFoam.cxx:3177
 PDEFoam.cxx:3178
 PDEFoam.cxx:3179
 PDEFoam.cxx:3180
 PDEFoam.cxx:3181
 PDEFoam.cxx:3182
 PDEFoam.cxx:3183
 PDEFoam.cxx:3184
 PDEFoam.cxx:3185
 PDEFoam.cxx:3186
 PDEFoam.cxx:3187
 PDEFoam.cxx:3188
 PDEFoam.cxx:3189
 PDEFoam.cxx:3190
 PDEFoam.cxx:3191
 PDEFoam.cxx:3192
 PDEFoam.cxx:3193
 PDEFoam.cxx:3194
 PDEFoam.cxx:3195
 PDEFoam.cxx:3196
 PDEFoam.cxx:3197
 PDEFoam.cxx:3198
 PDEFoam.cxx:3199
 PDEFoam.cxx:3200
 PDEFoam.cxx:3201
 PDEFoam.cxx:3202
 PDEFoam.cxx:3203
 PDEFoam.cxx:3204
 PDEFoam.cxx:3205
 PDEFoam.cxx:3206
 PDEFoam.cxx:3207
 PDEFoam.cxx:3208
 PDEFoam.cxx:3209
 PDEFoam.cxx:3210
 PDEFoam.cxx:3211
 PDEFoam.cxx:3212
 PDEFoam.cxx:3213
 PDEFoam.cxx:3214
 PDEFoam.cxx:3215
 PDEFoam.cxx:3216
 PDEFoam.cxx:3217
 PDEFoam.cxx:3218
 PDEFoam.cxx:3219
 PDEFoam.cxx:3220
 PDEFoam.cxx:3221
 PDEFoam.cxx:3222
 PDEFoam.cxx:3223
 PDEFoam.cxx:3224
 PDEFoam.cxx:3225
 PDEFoam.cxx:3226
 PDEFoam.cxx:3227
 PDEFoam.cxx:3228
 PDEFoam.cxx:3229
 PDEFoam.cxx:3230
 PDEFoam.cxx:3231
 PDEFoam.cxx:3232
 PDEFoam.cxx:3233
 PDEFoam.cxx:3234
 PDEFoam.cxx:3235
 PDEFoam.cxx:3236
 PDEFoam.cxx:3237
 PDEFoam.cxx:3238
 PDEFoam.cxx:3239
 PDEFoam.cxx:3240
 PDEFoam.cxx:3241
 PDEFoam.cxx:3242
 PDEFoam.cxx:3243
 PDEFoam.cxx:3244
 PDEFoam.cxx:3245
 PDEFoam.cxx:3246
 PDEFoam.cxx:3247
 PDEFoam.cxx:3248
 PDEFoam.cxx:3249
 PDEFoam.cxx:3250
 PDEFoam.cxx:3251
 PDEFoam.cxx:3252
 PDEFoam.cxx:3253
 PDEFoam.cxx:3254
 PDEFoam.cxx:3255
 PDEFoam.cxx:3256
 PDEFoam.cxx:3257
 PDEFoam.cxx:3258
 PDEFoam.cxx:3259
 PDEFoam.cxx:3260
 PDEFoam.cxx:3261
 PDEFoam.cxx:3262
 PDEFoam.cxx:3263
 PDEFoam.cxx:3264
 PDEFoam.cxx:3265
 PDEFoam.cxx:3266
 PDEFoam.cxx:3267
 PDEFoam.cxx:3268
 PDEFoam.cxx:3269
 PDEFoam.cxx:3270
 PDEFoam.cxx:3271
 PDEFoam.cxx:3272
 PDEFoam.cxx:3273
 PDEFoam.cxx:3274
 PDEFoam.cxx:3275
 PDEFoam.cxx:3276
 PDEFoam.cxx:3277
 PDEFoam.cxx:3278
 PDEFoam.cxx:3279
 PDEFoam.cxx:3280
 PDEFoam.cxx:3281
 PDEFoam.cxx:3282
 PDEFoam.cxx:3283
 PDEFoam.cxx:3284
 PDEFoam.cxx:3285
 PDEFoam.cxx:3286
 PDEFoam.cxx:3287
 PDEFoam.cxx:3288
 PDEFoam.cxx:3289
 PDEFoam.cxx:3290
 PDEFoam.cxx:3291
 PDEFoam.cxx:3292
 PDEFoam.cxx:3293
 PDEFoam.cxx:3294
 PDEFoam.cxx:3295
 PDEFoam.cxx:3296
 PDEFoam.cxx:3297
 PDEFoam.cxx:3298
 PDEFoam.cxx:3299
 PDEFoam.cxx:3300
 PDEFoam.cxx:3301
 PDEFoam.cxx:3302
 PDEFoam.cxx:3303
 PDEFoam.cxx:3304
 PDEFoam.cxx:3305
 PDEFoam.cxx:3306
 PDEFoam.cxx:3307
 PDEFoam.cxx:3308
 PDEFoam.cxx:3309
 PDEFoam.cxx:3310
 PDEFoam.cxx:3311
 PDEFoam.cxx:3312
 PDEFoam.cxx:3313
 PDEFoam.cxx:3314
 PDEFoam.cxx:3315
 PDEFoam.cxx:3316
 PDEFoam.cxx:3317
 PDEFoam.cxx:3318
 PDEFoam.cxx:3319
 PDEFoam.cxx:3320
 PDEFoam.cxx:3321
 PDEFoam.cxx:3322
 PDEFoam.cxx:3323
 PDEFoam.cxx:3324
 PDEFoam.cxx:3325
 PDEFoam.cxx:3326
 PDEFoam.cxx:3327
 PDEFoam.cxx:3328
 PDEFoam.cxx:3329
 PDEFoam.cxx:3330
 PDEFoam.cxx:3331
 PDEFoam.cxx:3332
 PDEFoam.cxx:3333
 PDEFoam.cxx:3334
 PDEFoam.cxx:3335
 PDEFoam.cxx:3336
 PDEFoam.cxx:3337
 PDEFoam.cxx:3338
 PDEFoam.cxx:3339
 PDEFoam.cxx:3340
 PDEFoam.cxx:3341
 PDEFoam.cxx:3342
 PDEFoam.cxx:3343
 PDEFoam.cxx:3344
 PDEFoam.cxx:3345
 PDEFoam.cxx:3346
 PDEFoam.cxx:3347
 PDEFoam.cxx:3348
 PDEFoam.cxx:3349
 PDEFoam.cxx:3350
 PDEFoam.cxx:3351
 PDEFoam.cxx:3352
 PDEFoam.cxx:3353
 PDEFoam.cxx:3354
 PDEFoam.cxx:3355
 PDEFoam.cxx:3356
 PDEFoam.cxx:3357
 PDEFoam.cxx:3358
 PDEFoam.cxx:3359
 PDEFoam.cxx:3360
 PDEFoam.cxx:3361
 PDEFoam.cxx:3362
 PDEFoam.cxx:3363
 PDEFoam.cxx:3364
 PDEFoam.cxx:3365
 PDEFoam.cxx:3366
 PDEFoam.cxx:3367
 PDEFoam.cxx:3368
 PDEFoam.cxx:3369
 PDEFoam.cxx:3370
 PDEFoam.cxx:3371
 PDEFoam.cxx:3372
 PDEFoam.cxx:3373
 PDEFoam.cxx:3374
 PDEFoam.cxx:3375
 PDEFoam.cxx:3376
 PDEFoam.cxx:3377
 PDEFoam.cxx:3378
 PDEFoam.cxx:3379
 PDEFoam.cxx:3380
 PDEFoam.cxx:3381
 PDEFoam.cxx:3382
 PDEFoam.cxx:3383
 PDEFoam.cxx:3384
 PDEFoam.cxx:3385
 PDEFoam.cxx:3386
 PDEFoam.cxx:3387
 PDEFoam.cxx:3388
 PDEFoam.cxx:3389
 PDEFoam.cxx:3390
 PDEFoam.cxx:3391
 PDEFoam.cxx:3392
 PDEFoam.cxx:3393
 PDEFoam.cxx:3394
 PDEFoam.cxx:3395
 PDEFoam.cxx:3396
 PDEFoam.cxx:3397
 PDEFoam.cxx:3398
 PDEFoam.cxx:3399
 PDEFoam.cxx:3400
 PDEFoam.cxx:3401
 PDEFoam.cxx:3402
 PDEFoam.cxx:3403
 PDEFoam.cxx:3404
 PDEFoam.cxx:3405
 PDEFoam.cxx:3406
 PDEFoam.cxx:3407
 PDEFoam.cxx:3408
 PDEFoam.cxx:3409
 PDEFoam.cxx:3410
 PDEFoam.cxx:3411
 PDEFoam.cxx:3412
 PDEFoam.cxx:3413
 PDEFoam.cxx:3414
 PDEFoam.cxx:3415
 PDEFoam.cxx:3416
 PDEFoam.cxx:3417
 PDEFoam.cxx:3418
 PDEFoam.cxx:3419
 PDEFoam.cxx:3420
 PDEFoam.cxx:3421
 PDEFoam.cxx:3422
 PDEFoam.cxx:3423
 PDEFoam.cxx:3424
 PDEFoam.cxx:3425
 PDEFoam.cxx:3426
 PDEFoam.cxx:3427
 PDEFoam.cxx:3428
 PDEFoam.cxx:3429
 PDEFoam.cxx:3430
 PDEFoam.cxx:3431
 PDEFoam.cxx:3432
 PDEFoam.cxx:3433
 PDEFoam.cxx:3434
 PDEFoam.cxx:3435
 PDEFoam.cxx:3436
 PDEFoam.cxx:3437
 PDEFoam.cxx:3438
 PDEFoam.cxx:3439
 PDEFoam.cxx:3440
 PDEFoam.cxx:3441
 PDEFoam.cxx:3442
 PDEFoam.cxx:3443
 PDEFoam.cxx:3444
 PDEFoam.cxx:3445
 PDEFoam.cxx:3446
 PDEFoam.cxx:3447
 PDEFoam.cxx:3448
 PDEFoam.cxx:3449
 PDEFoam.cxx:3450
 PDEFoam.cxx:3451
 PDEFoam.cxx:3452
 PDEFoam.cxx:3453
 PDEFoam.cxx:3454
 PDEFoam.cxx:3455
 PDEFoam.cxx:3456
 PDEFoam.cxx:3457
 PDEFoam.cxx:3458
 PDEFoam.cxx:3459
 PDEFoam.cxx:3460
 PDEFoam.cxx:3461
 PDEFoam.cxx:3462
 PDEFoam.cxx:3463
 PDEFoam.cxx:3464
 PDEFoam.cxx:3465
 PDEFoam.cxx:3466
 PDEFoam.cxx:3467
 PDEFoam.cxx:3468
 PDEFoam.cxx:3469
 PDEFoam.cxx:3470
 PDEFoam.cxx:3471
 PDEFoam.cxx:3472
 PDEFoam.cxx:3473
 PDEFoam.cxx:3474
 PDEFoam.cxx:3475
 PDEFoam.cxx:3476
 PDEFoam.cxx:3477
 PDEFoam.cxx:3478
 PDEFoam.cxx:3479
 PDEFoam.cxx:3480
 PDEFoam.cxx:3481
 PDEFoam.cxx:3482
 PDEFoam.cxx:3483
 PDEFoam.cxx:3484
 PDEFoam.cxx:3485
 PDEFoam.cxx:3486
 PDEFoam.cxx:3487
 PDEFoam.cxx:3488
 PDEFoam.cxx:3489
 PDEFoam.cxx:3490
 PDEFoam.cxx:3491
 PDEFoam.cxx:3492
 PDEFoam.cxx:3493
 PDEFoam.cxx:3494
 PDEFoam.cxx:3495
 PDEFoam.cxx:3496
 PDEFoam.cxx:3497
 PDEFoam.cxx:3498
 PDEFoam.cxx:3499
 PDEFoam.cxx:3500
 PDEFoam.cxx:3501
 PDEFoam.cxx:3502
 PDEFoam.cxx:3503
 PDEFoam.cxx:3504
 PDEFoam.cxx:3505
 PDEFoam.cxx:3506
 PDEFoam.cxx:3507
 PDEFoam.cxx:3508
 PDEFoam.cxx:3509
 PDEFoam.cxx:3510
 PDEFoam.cxx:3511
 PDEFoam.cxx:3512
 PDEFoam.cxx:3513
 PDEFoam.cxx:3514
 PDEFoam.cxx:3515
 PDEFoam.cxx:3516
 PDEFoam.cxx:3517
 PDEFoam.cxx:3518
 PDEFoam.cxx:3519
 PDEFoam.cxx:3520
 PDEFoam.cxx:3521
 PDEFoam.cxx:3522
 PDEFoam.cxx:3523
 PDEFoam.cxx:3524
 PDEFoam.cxx:3525
 PDEFoam.cxx:3526
 PDEFoam.cxx:3527
 PDEFoam.cxx:3528
 PDEFoam.cxx:3529
 PDEFoam.cxx:3530
 PDEFoam.cxx:3531
 PDEFoam.cxx:3532
 PDEFoam.cxx:3533
 PDEFoam.cxx:3534
 PDEFoam.cxx:3535
 PDEFoam.cxx:3536
 PDEFoam.cxx:3537
 PDEFoam.cxx:3538
 PDEFoam.cxx:3539
 PDEFoam.cxx:3540
 PDEFoam.cxx:3541
 PDEFoam.cxx:3542
 PDEFoam.cxx:3543
 PDEFoam.cxx:3544
 PDEFoam.cxx:3545
 PDEFoam.cxx:3546
 PDEFoam.cxx:3547
 PDEFoam.cxx:3548
 PDEFoam.cxx:3549
 PDEFoam.cxx:3550
 PDEFoam.cxx:3551
 PDEFoam.cxx:3552
 PDEFoam.cxx:3553
 PDEFoam.cxx:3554
 PDEFoam.cxx:3555
 PDEFoam.cxx:3556
 PDEFoam.cxx:3557
 PDEFoam.cxx:3558
 PDEFoam.cxx:3559
 PDEFoam.cxx:3560
 PDEFoam.cxx:3561
 PDEFoam.cxx:3562
 PDEFoam.cxx:3563
 PDEFoam.cxx:3564
 PDEFoam.cxx:3565
 PDEFoam.cxx:3566
 PDEFoam.cxx:3567
 PDEFoam.cxx:3568
 PDEFoam.cxx:3569
 PDEFoam.cxx:3570
 PDEFoam.cxx:3571
 PDEFoam.cxx:3572
 PDEFoam.cxx:3573
 PDEFoam.cxx:3574
 PDEFoam.cxx:3575
 PDEFoam.cxx:3576
 PDEFoam.cxx:3577
 PDEFoam.cxx:3578
 PDEFoam.cxx:3579
 PDEFoam.cxx:3580
 PDEFoam.cxx:3581
 PDEFoam.cxx:3582
 PDEFoam.cxx:3583
 PDEFoam.cxx:3584
 PDEFoam.cxx:3585
 PDEFoam.cxx:3586
 PDEFoam.cxx:3587
 PDEFoam.cxx:3588
 PDEFoam.cxx:3589
 PDEFoam.cxx:3590
 PDEFoam.cxx:3591
 PDEFoam.cxx:3592
 PDEFoam.cxx:3593
 PDEFoam.cxx:3594
 PDEFoam.cxx:3595
 PDEFoam.cxx:3596
 PDEFoam.cxx:3597
 PDEFoam.cxx:3598
 PDEFoam.cxx:3599
 PDEFoam.cxx:3600
 PDEFoam.cxx:3601
 PDEFoam.cxx:3602
 PDEFoam.cxx:3603
 PDEFoam.cxx:3604
 PDEFoam.cxx:3605
 PDEFoam.cxx:3606
 PDEFoam.cxx:3607
 PDEFoam.cxx:3608
 PDEFoam.cxx:3609
 PDEFoam.cxx:3610
 PDEFoam.cxx:3611
 PDEFoam.cxx:3612
 PDEFoam.cxx:3613
 PDEFoam.cxx:3614
 PDEFoam.cxx:3615
 PDEFoam.cxx:3616
 PDEFoam.cxx:3617
 PDEFoam.cxx:3618
 PDEFoam.cxx:3619
 PDEFoam.cxx:3620
 PDEFoam.cxx:3621
 PDEFoam.cxx:3622
 PDEFoam.cxx:3623
 PDEFoam.cxx:3624
 PDEFoam.cxx:3625
 PDEFoam.cxx:3626
 PDEFoam.cxx:3627
 PDEFoam.cxx:3628
 PDEFoam.cxx:3629
 PDEFoam.cxx:3630
 PDEFoam.cxx:3631
 PDEFoam.cxx:3632
 PDEFoam.cxx:3633
 PDEFoam.cxx:3634
 PDEFoam.cxx:3635
 PDEFoam.cxx:3636
 PDEFoam.cxx:3637
 PDEFoam.cxx:3638
 PDEFoam.cxx:3639
 PDEFoam.cxx:3640
 PDEFoam.cxx:3641
 PDEFoam.cxx:3642
 PDEFoam.cxx:3643
 PDEFoam.cxx:3644
 PDEFoam.cxx:3645
 PDEFoam.cxx:3646
 PDEFoam.cxx:3647
 PDEFoam.cxx:3648
 PDEFoam.cxx:3649
 PDEFoam.cxx:3650
 PDEFoam.cxx:3651
 PDEFoam.cxx:3652
 PDEFoam.cxx:3653
 PDEFoam.cxx:3654
 PDEFoam.cxx:3655
 PDEFoam.cxx:3656
 PDEFoam.cxx:3657
 PDEFoam.cxx:3658
 PDEFoam.cxx:3659
 PDEFoam.cxx:3660
 PDEFoam.cxx:3661
 PDEFoam.cxx:3662
 PDEFoam.cxx:3663
 PDEFoam.cxx:3664
 PDEFoam.cxx:3665
 PDEFoam.cxx:3666
 PDEFoam.cxx:3667
 PDEFoam.cxx:3668
 PDEFoam.cxx:3669
 PDEFoam.cxx:3670
 PDEFoam.cxx:3671
 PDEFoam.cxx:3672
 PDEFoam.cxx:3673
 PDEFoam.cxx:3674
 PDEFoam.cxx:3675
 PDEFoam.cxx:3676
 PDEFoam.cxx:3677
 PDEFoam.cxx:3678
 PDEFoam.cxx:3679
 PDEFoam.cxx:3680
 PDEFoam.cxx:3681
 PDEFoam.cxx:3682
 PDEFoam.cxx:3683
 PDEFoam.cxx:3684
 PDEFoam.cxx:3685
 PDEFoam.cxx:3686
 PDEFoam.cxx:3687
 PDEFoam.cxx:3688
 PDEFoam.cxx:3689
 PDEFoam.cxx:3690
 PDEFoam.cxx:3691
 PDEFoam.cxx:3692
 PDEFoam.cxx:3693
 PDEFoam.cxx:3694
 PDEFoam.cxx:3695
 PDEFoam.cxx:3696
 PDEFoam.cxx:3697
 PDEFoam.cxx:3698
 PDEFoam.cxx:3699
 PDEFoam.cxx:3700
 PDEFoam.cxx:3701
 PDEFoam.cxx:3702
 PDEFoam.cxx:3703
 PDEFoam.cxx:3704
 PDEFoam.cxx:3705
 PDEFoam.cxx:3706
 PDEFoam.cxx:3707
 PDEFoam.cxx:3708
 PDEFoam.cxx:3709
 PDEFoam.cxx:3710
 PDEFoam.cxx:3711
 PDEFoam.cxx:3712
 PDEFoam.cxx:3713
 PDEFoam.cxx:3714
 PDEFoam.cxx:3715
 PDEFoam.cxx:3716
 PDEFoam.cxx:3717
 PDEFoam.cxx:3718
 PDEFoam.cxx:3719
 PDEFoam.cxx:3720
 PDEFoam.cxx:3721
 PDEFoam.cxx:3722
 PDEFoam.cxx:3723
 PDEFoam.cxx:3724
 PDEFoam.cxx:3725
 PDEFoam.cxx:3726
 PDEFoam.cxx:3727
 PDEFoam.cxx:3728
 PDEFoam.cxx:3729
 PDEFoam.cxx:3730
 PDEFoam.cxx:3731
 PDEFoam.cxx:3732
 PDEFoam.cxx:3733
 PDEFoam.cxx:3734
 PDEFoam.cxx:3735
 PDEFoam.cxx:3736
 PDEFoam.cxx:3737
 PDEFoam.cxx:3738
 PDEFoam.cxx:3739
 PDEFoam.cxx:3740
 PDEFoam.cxx:3741
 PDEFoam.cxx:3742
 PDEFoam.cxx:3743
 PDEFoam.cxx:3744
 PDEFoam.cxx:3745
 PDEFoam.cxx:3746
 PDEFoam.cxx:3747
 PDEFoam.cxx:3748
 PDEFoam.cxx:3749
 PDEFoam.cxx:3750
 PDEFoam.cxx:3751
 PDEFoam.cxx:3752
 PDEFoam.cxx:3753
 PDEFoam.cxx:3754
 PDEFoam.cxx:3755
 PDEFoam.cxx:3756
 PDEFoam.cxx:3757
 PDEFoam.cxx:3758
 PDEFoam.cxx:3759
 PDEFoam.cxx:3760
 PDEFoam.cxx:3761
 PDEFoam.cxx:3762
 PDEFoam.cxx:3763
 PDEFoam.cxx:3764
 PDEFoam.cxx:3765
 PDEFoam.cxx:3766
 PDEFoam.cxx:3767
 PDEFoam.cxx:3768
 PDEFoam.cxx:3769
 PDEFoam.cxx:3770
 PDEFoam.cxx:3771
 PDEFoam.cxx:3772
 PDEFoam.cxx:3773
 PDEFoam.cxx:3774
 PDEFoam.cxx:3775
 PDEFoam.cxx:3776
 PDEFoam.cxx:3777
 PDEFoam.cxx:3778
 PDEFoam.cxx:3779
 PDEFoam.cxx:3780
 PDEFoam.cxx:3781
 PDEFoam.cxx:3782
 PDEFoam.cxx:3783
 PDEFoam.cxx:3784
 PDEFoam.cxx:3785
 PDEFoam.cxx:3786
 PDEFoam.cxx:3787
 PDEFoam.cxx:3788
 PDEFoam.cxx:3789
 PDEFoam.cxx:3790
 PDEFoam.cxx:3791
 PDEFoam.cxx:3792
 PDEFoam.cxx:3793
 PDEFoam.cxx:3794
 PDEFoam.cxx:3795
 PDEFoam.cxx:3796
 PDEFoam.cxx:3797
 PDEFoam.cxx:3798
 PDEFoam.cxx:3799
 PDEFoam.cxx:3800
 PDEFoam.cxx:3801
 PDEFoam.cxx:3802
 PDEFoam.cxx:3803
 PDEFoam.cxx:3804
 PDEFoam.cxx:3805
 PDEFoam.cxx:3806
 PDEFoam.cxx:3807
 PDEFoam.cxx:3808
 PDEFoam.cxx:3809
 PDEFoam.cxx:3810
 PDEFoam.cxx:3811
 PDEFoam.cxx:3812
 PDEFoam.cxx:3813
 PDEFoam.cxx:3814
 PDEFoam.cxx:3815
 PDEFoam.cxx:3816
 PDEFoam.cxx:3817
 PDEFoam.cxx:3818
 PDEFoam.cxx:3819
 PDEFoam.cxx:3820
 PDEFoam.cxx:3821
 PDEFoam.cxx:3822
 PDEFoam.cxx:3823
 PDEFoam.cxx:3824
 PDEFoam.cxx:3825
 PDEFoam.cxx:3826
 PDEFoam.cxx:3827
 PDEFoam.cxx:3828
 PDEFoam.cxx:3829
 PDEFoam.cxx:3830
 PDEFoam.cxx:3831
 PDEFoam.cxx:3832
 PDEFoam.cxx:3833
 PDEFoam.cxx:3834
 PDEFoam.cxx:3835
 PDEFoam.cxx:3836
 PDEFoam.cxx:3837
 PDEFoam.cxx:3838
 PDEFoam.cxx:3839
 PDEFoam.cxx:3840
 PDEFoam.cxx:3841
 PDEFoam.cxx:3842
 PDEFoam.cxx:3843
 PDEFoam.cxx:3844
 PDEFoam.cxx:3845
 PDEFoam.cxx:3846
 PDEFoam.cxx:3847
 PDEFoam.cxx:3848
 PDEFoam.cxx:3849
 PDEFoam.cxx:3850
 PDEFoam.cxx:3851
 PDEFoam.cxx:3852
 PDEFoam.cxx:3853
 PDEFoam.cxx:3854
 PDEFoam.cxx:3855
 PDEFoam.cxx:3856
 PDEFoam.cxx:3857
 PDEFoam.cxx:3858
 PDEFoam.cxx:3859
 PDEFoam.cxx:3860
 PDEFoam.cxx:3861
 PDEFoam.cxx:3862
 PDEFoam.cxx:3863
 PDEFoam.cxx:3864
 PDEFoam.cxx:3865
 PDEFoam.cxx:3866
 PDEFoam.cxx:3867
 PDEFoam.cxx:3868
 PDEFoam.cxx:3869
 PDEFoam.cxx:3870
 PDEFoam.cxx:3871
 PDEFoam.cxx:3872
 PDEFoam.cxx:3873
 PDEFoam.cxx:3874
 PDEFoam.cxx:3875
 PDEFoam.cxx:3876
 PDEFoam.cxx:3877
 PDEFoam.cxx:3878
 PDEFoam.cxx:3879
 PDEFoam.cxx:3880
 PDEFoam.cxx:3881
 PDEFoam.cxx:3882
 PDEFoam.cxx:3883
 PDEFoam.cxx:3884
 PDEFoam.cxx:3885
 PDEFoam.cxx:3886
 PDEFoam.cxx:3887
 PDEFoam.cxx:3888
 PDEFoam.cxx:3889
 PDEFoam.cxx:3890
 PDEFoam.cxx:3891
 PDEFoam.cxx:3892
 PDEFoam.cxx:3893
 PDEFoam.cxx:3894
 PDEFoam.cxx:3895
 PDEFoam.cxx:3896
 PDEFoam.cxx:3897
 PDEFoam.cxx:3898
 PDEFoam.cxx:3899
 PDEFoam.cxx:3900
 PDEFoam.cxx:3901
 PDEFoam.cxx:3902
 PDEFoam.cxx:3903
 PDEFoam.cxx:3904
 PDEFoam.cxx:3905
 PDEFoam.cxx:3906
 PDEFoam.cxx:3907
 PDEFoam.cxx:3908
 PDEFoam.cxx:3909
 PDEFoam.cxx:3910
 PDEFoam.cxx:3911
 PDEFoam.cxx:3912
 PDEFoam.cxx:3913
 PDEFoam.cxx:3914
 PDEFoam.cxx:3915
 PDEFoam.cxx:3916
 PDEFoam.cxx:3917
 PDEFoam.cxx:3918
 PDEFoam.cxx:3919
 PDEFoam.cxx:3920
 PDEFoam.cxx:3921
 PDEFoam.cxx:3922
 PDEFoam.cxx:3923
 PDEFoam.cxx:3924
 PDEFoam.cxx:3925
 PDEFoam.cxx:3926
 PDEFoam.cxx:3927
 PDEFoam.cxx:3928
 PDEFoam.cxx:3929
 PDEFoam.cxx:3930
 PDEFoam.cxx:3931
 PDEFoam.cxx:3932
 PDEFoam.cxx:3933
 PDEFoam.cxx:3934
 PDEFoam.cxx:3935
 PDEFoam.cxx:3936
 PDEFoam.cxx:3937
 PDEFoam.cxx:3938
 PDEFoam.cxx:3939
 PDEFoam.cxx:3940
 PDEFoam.cxx:3941
 PDEFoam.cxx:3942
 PDEFoam.cxx:3943
 PDEFoam.cxx:3944
 PDEFoam.cxx:3945
 PDEFoam.cxx:3946
 PDEFoam.cxx:3947
 PDEFoam.cxx:3948
 PDEFoam.cxx:3949
 PDEFoam.cxx:3950
 PDEFoam.cxx:3951
 PDEFoam.cxx:3952
 PDEFoam.cxx:3953
 PDEFoam.cxx:3954
 PDEFoam.cxx:3955
 PDEFoam.cxx:3956
 PDEFoam.cxx:3957
 PDEFoam.cxx:3958
 PDEFoam.cxx:3959
 PDEFoam.cxx:3960
 PDEFoam.cxx:3961
 PDEFoam.cxx:3962
 PDEFoam.cxx:3963
 PDEFoam.cxx:3964
 PDEFoam.cxx:3965
 PDEFoam.cxx:3966
 PDEFoam.cxx:3967
 PDEFoam.cxx:3968
 PDEFoam.cxx:3969
 PDEFoam.cxx:3970
 PDEFoam.cxx:3971
 PDEFoam.cxx:3972
 PDEFoam.cxx:3973
 PDEFoam.cxx:3974
 PDEFoam.cxx:3975
 PDEFoam.cxx:3976
 PDEFoam.cxx:3977
 PDEFoam.cxx:3978
 PDEFoam.cxx:3979
 PDEFoam.cxx:3980
 PDEFoam.cxx:3981
 PDEFoam.cxx:3982
 PDEFoam.cxx:3983
 PDEFoam.cxx:3984
 PDEFoam.cxx:3985
 PDEFoam.cxx:3986
 PDEFoam.cxx:3987
 PDEFoam.cxx:3988
 PDEFoam.cxx:3989
 PDEFoam.cxx:3990
 PDEFoam.cxx:3991
 PDEFoam.cxx:3992
 PDEFoam.cxx:3993
 PDEFoam.cxx:3994
 PDEFoam.cxx:3995
 PDEFoam.cxx:3996
 PDEFoam.cxx:3997
 PDEFoam.cxx:3998
 PDEFoam.cxx:3999
 PDEFoam.cxx:4000
 PDEFoam.cxx:4001
 PDEFoam.cxx:4002
 PDEFoam.cxx:4003
 PDEFoam.cxx:4004
 PDEFoam.cxx:4005
 PDEFoam.cxx:4006
 PDEFoam.cxx:4007
 PDEFoam.cxx:4008
 PDEFoam.cxx:4009
 PDEFoam.cxx:4010
 PDEFoam.cxx:4011
 PDEFoam.cxx:4012
 PDEFoam.cxx:4013
 PDEFoam.cxx:4014
 PDEFoam.cxx:4015
 PDEFoam.cxx:4016
 PDEFoam.cxx:4017
 PDEFoam.cxx:4018
 PDEFoam.cxx:4019
 PDEFoam.cxx:4020
 PDEFoam.cxx:4021
 PDEFoam.cxx:4022
 PDEFoam.cxx:4023
 PDEFoam.cxx:4024
 PDEFoam.cxx:4025
 PDEFoam.cxx:4026
 PDEFoam.cxx:4027
 PDEFoam.cxx:4028
 PDEFoam.cxx:4029
 PDEFoam.cxx:4030
 PDEFoam.cxx:4031
 PDEFoam.cxx:4032
 PDEFoam.cxx:4033
 PDEFoam.cxx:4034
 PDEFoam.cxx:4035
 PDEFoam.cxx:4036
 PDEFoam.cxx:4037
 PDEFoam.cxx:4038
 PDEFoam.cxx:4039
 PDEFoam.cxx:4040
 PDEFoam.cxx:4041
 PDEFoam.cxx:4042
 PDEFoam.cxx:4043
 PDEFoam.cxx:4044
 PDEFoam.cxx:4045
 PDEFoam.cxx:4046
 PDEFoam.cxx:4047
 PDEFoam.cxx:4048
 PDEFoam.cxx:4049
 PDEFoam.cxx:4050
 PDEFoam.cxx:4051
 PDEFoam.cxx:4052
 PDEFoam.cxx:4053
 PDEFoam.cxx:4054
 PDEFoam.cxx:4055
 PDEFoam.cxx:4056
 PDEFoam.cxx:4057
 PDEFoam.cxx:4058
 PDEFoam.cxx:4059
 PDEFoam.cxx:4060
 PDEFoam.cxx:4061
 PDEFoam.cxx:4062
 PDEFoam.cxx:4063
 PDEFoam.cxx:4064
 PDEFoam.cxx:4065
 PDEFoam.cxx:4066
 PDEFoam.cxx:4067
 PDEFoam.cxx:4068
 PDEFoam.cxx:4069
 PDEFoam.cxx:4070
 PDEFoam.cxx:4071
 PDEFoam.cxx:4072
 PDEFoam.cxx:4073
 PDEFoam.cxx:4074
 PDEFoam.cxx:4075
 PDEFoam.cxx:4076
 PDEFoam.cxx:4077
 PDEFoam.cxx:4078
 PDEFoam.cxx:4079
 PDEFoam.cxx:4080
 PDEFoam.cxx:4081
 PDEFoam.cxx:4082
 PDEFoam.cxx:4083
 PDEFoam.cxx:4084
 PDEFoam.cxx:4085
 PDEFoam.cxx:4086
 PDEFoam.cxx:4087
 PDEFoam.cxx:4088
 PDEFoam.cxx:4089
 PDEFoam.cxx:4090
 PDEFoam.cxx:4091
 PDEFoam.cxx:4092
 PDEFoam.cxx:4093
 PDEFoam.cxx:4094
 PDEFoam.cxx:4095
 PDEFoam.cxx:4096
 PDEFoam.cxx:4097
 PDEFoam.cxx:4098
 PDEFoam.cxx:4099
 PDEFoam.cxx:4100
 PDEFoam.cxx:4101
 PDEFoam.cxx:4102
 PDEFoam.cxx:4103
 PDEFoam.cxx:4104
 PDEFoam.cxx:4105
 PDEFoam.cxx:4106
 PDEFoam.cxx:4107
 PDEFoam.cxx:4108
 PDEFoam.cxx:4109
 PDEFoam.cxx:4110
 PDEFoam.cxx:4111
 PDEFoam.cxx:4112
 PDEFoam.cxx:4113
 PDEFoam.cxx:4114
 PDEFoam.cxx:4115
 PDEFoam.cxx:4116
 PDEFoam.cxx:4117
 PDEFoam.cxx:4118
 PDEFoam.cxx:4119
 PDEFoam.cxx:4120
 PDEFoam.cxx:4121
 PDEFoam.cxx:4122
 PDEFoam.cxx:4123
 PDEFoam.cxx:4124
 PDEFoam.cxx:4125
 PDEFoam.cxx:4126
 PDEFoam.cxx:4127
 PDEFoam.cxx:4128
 PDEFoam.cxx:4129
 PDEFoam.cxx:4130
 PDEFoam.cxx:4131
 PDEFoam.cxx:4132
 PDEFoam.cxx:4133
 PDEFoam.cxx:4134
 PDEFoam.cxx:4135
 PDEFoam.cxx:4136
 PDEFoam.cxx:4137
 PDEFoam.cxx:4138
 PDEFoam.cxx:4139
 PDEFoam.cxx:4140
 PDEFoam.cxx:4141
 PDEFoam.cxx:4142
 PDEFoam.cxx:4143
 PDEFoam.cxx:4144
 PDEFoam.cxx:4145
 PDEFoam.cxx:4146
 PDEFoam.cxx:4147
 PDEFoam.cxx:4148
 PDEFoam.cxx:4149
 PDEFoam.cxx:4150
 PDEFoam.cxx:4151
 PDEFoam.cxx:4152
 PDEFoam.cxx:4153
 PDEFoam.cxx:4154
 PDEFoam.cxx:4155
 PDEFoam.cxx:4156
 PDEFoam.cxx:4157
 PDEFoam.cxx:4158
 PDEFoam.cxx:4159
 PDEFoam.cxx:4160
 PDEFoam.cxx:4161
 PDEFoam.cxx:4162
 PDEFoam.cxx:4163
 PDEFoam.cxx:4164
 PDEFoam.cxx:4165
 PDEFoam.cxx:4166
 PDEFoam.cxx:4167
 PDEFoam.cxx:4168
 PDEFoam.cxx:4169
 PDEFoam.cxx:4170
 PDEFoam.cxx:4171
 PDEFoam.cxx:4172
 PDEFoam.cxx:4173
 PDEFoam.cxx:4174
 PDEFoam.cxx:4175
 PDEFoam.cxx:4176
 PDEFoam.cxx:4177
 PDEFoam.cxx:4178
 PDEFoam.cxx:4179
 PDEFoam.cxx:4180
 PDEFoam.cxx:4181
 PDEFoam.cxx:4182
 PDEFoam.cxx:4183
 PDEFoam.cxx:4184
 PDEFoam.cxx:4185
 PDEFoam.cxx:4186
 PDEFoam.cxx:4187
 PDEFoam.cxx:4188
 PDEFoam.cxx:4189
 PDEFoam.cxx:4190
 PDEFoam.cxx:4191
 PDEFoam.cxx:4192
 PDEFoam.cxx:4193
 PDEFoam.cxx:4194
 PDEFoam.cxx:4195
 PDEFoam.cxx:4196
 PDEFoam.cxx:4197
 PDEFoam.cxx:4198
 PDEFoam.cxx:4199
 PDEFoam.cxx:4200
 PDEFoam.cxx:4201
 PDEFoam.cxx:4202
 PDEFoam.cxx:4203
 PDEFoam.cxx:4204
 PDEFoam.cxx:4205
 PDEFoam.cxx:4206
 PDEFoam.cxx:4207
 PDEFoam.cxx:4208
 PDEFoam.cxx:4209
 PDEFoam.cxx:4210
 PDEFoam.cxx:4211
 PDEFoam.cxx:4212
 PDEFoam.cxx:4213
 PDEFoam.cxx:4214
 PDEFoam.cxx:4215
 PDEFoam.cxx:4216
 PDEFoam.cxx:4217
 PDEFoam.cxx:4218
 PDEFoam.cxx:4219
 PDEFoam.cxx:4220
 PDEFoam.cxx:4221
 PDEFoam.cxx:4222
 PDEFoam.cxx:4223
 PDEFoam.cxx:4224
 PDEFoam.cxx:4225
 PDEFoam.cxx:4226
 PDEFoam.cxx:4227
 PDEFoam.cxx:4228
 PDEFoam.cxx:4229
 PDEFoam.cxx:4230
 PDEFoam.cxx:4231
 PDEFoam.cxx:4232
 PDEFoam.cxx:4233
 PDEFoam.cxx:4234
 PDEFoam.cxx:4235
 PDEFoam.cxx:4236
 PDEFoam.cxx:4237
 PDEFoam.cxx:4238
 PDEFoam.cxx:4239
 PDEFoam.cxx:4240
 PDEFoam.cxx:4241
 PDEFoam.cxx:4242
 PDEFoam.cxx:4243
 PDEFoam.cxx:4244
 PDEFoam.cxx:4245
 PDEFoam.cxx:4246
 PDEFoam.cxx:4247
 PDEFoam.cxx:4248
 PDEFoam.cxx:4249
 PDEFoam.cxx:4250
 PDEFoam.cxx:4251
 PDEFoam.cxx:4252
 PDEFoam.cxx:4253
 PDEFoam.cxx:4254
 PDEFoam.cxx:4255
 PDEFoam.cxx:4256
 PDEFoam.cxx:4257
 PDEFoam.cxx:4258
 PDEFoam.cxx:4259
 PDEFoam.cxx:4260
 PDEFoam.cxx:4261
 PDEFoam.cxx:4262
 PDEFoam.cxx:4263
 PDEFoam.cxx:4264
 PDEFoam.cxx:4265
 PDEFoam.cxx:4266
 PDEFoam.cxx:4267
 PDEFoam.cxx:4268
 PDEFoam.cxx:4269
 PDEFoam.cxx:4270
 PDEFoam.cxx:4271
 PDEFoam.cxx:4272
 PDEFoam.cxx:4273
 PDEFoam.cxx:4274
 PDEFoam.cxx:4275
 PDEFoam.cxx:4276
 PDEFoam.cxx:4277
 PDEFoam.cxx:4278
 PDEFoam.cxx:4279
 PDEFoam.cxx:4280
 PDEFoam.cxx:4281
 PDEFoam.cxx:4282
 PDEFoam.cxx:4283
 PDEFoam.cxx:4284
 PDEFoam.cxx:4285
 PDEFoam.cxx:4286
 PDEFoam.cxx:4287
 PDEFoam.cxx:4288
 PDEFoam.cxx:4289
 PDEFoam.cxx:4290
 PDEFoam.cxx:4291
 PDEFoam.cxx:4292
 PDEFoam.cxx:4293
 PDEFoam.cxx:4294
 PDEFoam.cxx:4295
 PDEFoam.cxx:4296
 PDEFoam.cxx:4297
 PDEFoam.cxx:4298
 PDEFoam.cxx:4299
 PDEFoam.cxx:4300
 PDEFoam.cxx:4301
 PDEFoam.cxx:4302
 PDEFoam.cxx:4303
 PDEFoam.cxx:4304
 PDEFoam.cxx:4305
 PDEFoam.cxx:4306
 PDEFoam.cxx:4307
 PDEFoam.cxx:4308
 PDEFoam.cxx:4309
 PDEFoam.cxx:4310
 PDEFoam.cxx:4311
 PDEFoam.cxx:4312
 PDEFoam.cxx:4313
 PDEFoam.cxx:4314
 PDEFoam.cxx:4315
 PDEFoam.cxx:4316
 PDEFoam.cxx:4317
 PDEFoam.cxx:4318
 PDEFoam.cxx:4319
 PDEFoam.cxx:4320
 PDEFoam.cxx:4321
 PDEFoam.cxx:4322
 PDEFoam.cxx:4323
 PDEFoam.cxx:4324
 PDEFoam.cxx:4325
 PDEFoam.cxx:4326
 PDEFoam.cxx:4327
 PDEFoam.cxx:4328
 PDEFoam.cxx:4329
 PDEFoam.cxx:4330
 PDEFoam.cxx:4331
 PDEFoam.cxx:4332
 PDEFoam.cxx:4333
 PDEFoam.cxx:4334
 PDEFoam.cxx:4335
 PDEFoam.cxx:4336
 PDEFoam.cxx:4337
 PDEFoam.cxx:4338
 PDEFoam.cxx:4339
 PDEFoam.cxx:4340
 PDEFoam.cxx:4341
 PDEFoam.cxx:4342
 PDEFoam.cxx:4343
 PDEFoam.cxx:4344
 PDEFoam.cxx:4345
 PDEFoam.cxx:4346
 PDEFoam.cxx:4347
 PDEFoam.cxx:4348
 PDEFoam.cxx:4349
 PDEFoam.cxx:4350
 PDEFoam.cxx:4351
 PDEFoam.cxx:4352
 PDEFoam.cxx:4353
 PDEFoam.cxx:4354
 PDEFoam.cxx:4355
 PDEFoam.cxx:4356
 PDEFoam.cxx:4357
 PDEFoam.cxx:4358
 PDEFoam.cxx:4359
 PDEFoam.cxx:4360
 PDEFoam.cxx:4361
 PDEFoam.cxx:4362
 PDEFoam.cxx:4363
 PDEFoam.cxx:4364
 PDEFoam.cxx:4365
 PDEFoam.cxx:4366
 PDEFoam.cxx:4367
 PDEFoam.cxx:4368
 PDEFoam.cxx:4369
 PDEFoam.cxx:4370
 PDEFoam.cxx:4371
 PDEFoam.cxx:4372
 PDEFoam.cxx:4373
 PDEFoam.cxx:4374
 PDEFoam.cxx:4375
 PDEFoam.cxx:4376
 PDEFoam.cxx:4377
 PDEFoam.cxx:4378
 PDEFoam.cxx:4379
 PDEFoam.cxx:4380
 PDEFoam.cxx:4381
 PDEFoam.cxx:4382
 PDEFoam.cxx:4383
 PDEFoam.cxx:4384
 PDEFoam.cxx:4385
 PDEFoam.cxx:4386
 PDEFoam.cxx:4387
 PDEFoam.cxx:4388
 PDEFoam.cxx:4389
 PDEFoam.cxx:4390
 PDEFoam.cxx:4391
 PDEFoam.cxx:4392
 PDEFoam.cxx:4393
 PDEFoam.cxx:4394
 PDEFoam.cxx:4395
 PDEFoam.cxx:4396
 PDEFoam.cxx:4397
 PDEFoam.cxx:4398
 PDEFoam.cxx:4399
 PDEFoam.cxx:4400
 PDEFoam.cxx:4401
 PDEFoam.cxx:4402
 PDEFoam.cxx:4403
 PDEFoam.cxx:4404
 PDEFoam.cxx:4405
 PDEFoam.cxx:4406
 PDEFoam.cxx:4407
 PDEFoam.cxx:4408
 PDEFoam.cxx:4409
 PDEFoam.cxx:4410
 PDEFoam.cxx:4411
 PDEFoam.cxx:4412
 PDEFoam.cxx:4413
 PDEFoam.cxx:4414
 PDEFoam.cxx:4415
 PDEFoam.cxx:4416
 PDEFoam.cxx:4417
 PDEFoam.cxx:4418
 PDEFoam.cxx:4419
 PDEFoam.cxx:4420
 PDEFoam.cxx:4421
 PDEFoam.cxx:4422
 PDEFoam.cxx:4423
 PDEFoam.cxx:4424
 PDEFoam.cxx:4425
 PDEFoam.cxx:4426
 PDEFoam.cxx:4427
 PDEFoam.cxx:4428
 PDEFoam.cxx:4429
 PDEFoam.cxx:4430
 PDEFoam.cxx:4431
 PDEFoam.cxx:4432
 PDEFoam.cxx:4433
 PDEFoam.cxx:4434
 PDEFoam.cxx:4435
 PDEFoam.cxx:4436
 PDEFoam.cxx:4437
 PDEFoam.cxx:4438
 PDEFoam.cxx:4439
 PDEFoam.cxx:4440
 PDEFoam.cxx:4441
 PDEFoam.cxx:4442
 PDEFoam.cxx:4443
 PDEFoam.cxx:4444
 PDEFoam.cxx:4445
 PDEFoam.cxx:4446
 PDEFoam.cxx:4447
 PDEFoam.cxx:4448
 PDEFoam.cxx:4449
 PDEFoam.cxx:4450
 PDEFoam.cxx:4451
 PDEFoam.cxx:4452
 PDEFoam.cxx:4453
 PDEFoam.cxx:4454
 PDEFoam.cxx:4455
 PDEFoam.cxx:4456
 PDEFoam.cxx:4457
 PDEFoam.cxx:4458
 PDEFoam.cxx:4459
 PDEFoam.cxx:4460
 PDEFoam.cxx:4461
 PDEFoam.cxx:4462
 PDEFoam.cxx:4463
 PDEFoam.cxx:4464
 PDEFoam.cxx:4465
 PDEFoam.cxx:4466
 PDEFoam.cxx:4467
 PDEFoam.cxx:4468
 PDEFoam.cxx:4469
 PDEFoam.cxx:4470