ROOT logo
// @(#)root/tmva $Id: VariableGaussTransform.cxx 29195 2009-06-24 10:39:49Z brun $
// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Eckhard v. Toerne

/**********************************************************************************
 * Project: TMVA - a Root-integrated toolkit for multivariate data analysis       *
 * Package: TMVA                                                                  *
 * Class  : VariableGaussTransform                                                *
 * Web    : http://tmva.sourceforge.net                                           *
 *                                                                                *
 * Description:                                                                   *
 *      Implementation (see header for description)                               *
 *                                                                                *
 * Authors (alphabetical):                                                        *
 *      Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland              *
 *      Joerg Stelzer   <Joerg.Stelzer@cern.ch>  - CERN, Switzerland              *
 *      Eckhard v. Toerne     <evt@uni-bonn.de>  - Uni Bonn, Germany              *
 *      Helge Voss      <Helge.Voss@cern.ch>     - MPI-K Heidelberg, Germany      *
 *                                                                                *
 * Copyright (c) 2005:                                                            *
 *      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)                                          *
 **********************************************************************************/

///////////////////////////////////////////////////////////////////////////
//                                                                       //
// Gaussian Transformation of input variables.                           //
//                                                                       //
///////////////////////////////////////////////////////////////////////////

#include <iostream>
#include <iomanip>
#include <list>
#include <limits>

#include "TVectorF.h"
#include "TVectorD.h"
#include "TMath.h"
#include "TCanvas.h"
#include "TXMLEngine.h"

#ifndef ROOT_TMVA_MsgLogger
#include "TMVA/MsgLogger.h"
#endif
#include "TMVA/VariableGaussTransform.h"
#include "TMVA/Tools.h"

ClassImp(TMVA::VariableGaussTransform)

//_______________________________________________________________________
TMVA::VariableGaussTransform::VariableGaussTransform( DataSetInfo& dsi )
  : VariableTransformBase( dsi, Types::kGaussDecorr, "Gauss" ),
   fFlatNotGaussD(kFALSE), fPdfMinSmooth(0), fPdfMaxSmooth(0)
{ 
   // constructor
   // can only be applied one after the other when they are created. But in order to
   // determine the Gauss transformation
}

//_______________________________________________________________________
TMVA::VariableGaussTransform::~VariableGaussTransform( void )
{
   // destructor
   CleanUpCumulativeArrays();
}

//_______________________________________________________________________
void TMVA::VariableGaussTransform::Initialize()
{

}

//_______________________________________________________________________
Bool_t TMVA::VariableGaussTransform::PrepareTransformation( const std::vector<Event*>& events )
{
   // calculate the cumulative distributions
   Initialize();

   if (!IsEnabled() || IsCreated()) return kTRUE;

   Log() << kINFO << "Preparing the Gaussian transformation..." << Endl;

   SetNVariables(events[0]->GetNVariables());

   if (GetNVariables() > 200) { 
      Log() << kWARNING << "----------------------------------------------------------------------------" 
              << Endl;
      Log() << kWARNING 
              << ": More than 200 variables, I hope you have enough memory!!!!" << Endl;
      Log() << kWARNING << "----------------------------------------------------------------------------" 
              << Endl;
      //      return kFALSE;
   }   

   GetCumulativeDist( events );
   
   SetCreated( kTRUE );

   return kTRUE;
}

//_______________________________________________________________________
const TMVA::Event* TMVA::VariableGaussTransform::Transform(const Event* const ev, Int_t cls ) const
{
   // apply the Gauss transformation

   if (!IsCreated()) Log() << kFATAL << "Transformation not yet created" << Endl;

   if (cls <0 || cls >= GetNClasses() ) {
      cls = GetNClasses();
      if (GetNClasses() == 1 ) cls = (fCumulativePDF[0].size()==1?0:2);
   }

   // get the variable vector of the current event
   const UInt_t nvar = GetNVariables();
   TVectorD vec( nvar );
   for (UInt_t ivar=0; ivar<nvar; ivar++) vec(ivar) = ev->GetVal(ivar);
   Double_t cumulant;
   //transformation   
   for (UInt_t ivar=0; ivar<nvar; ivar++) {
      if (0 != fCumulativePDF[ivar][cls]) { 
         // first make it flat
         cumulant = (fCumulativePDF[ivar][cls])->GetVal(vec(ivar)); 
	 cumulant = TMath::Min(cumulant,1.-10e-10);
	 cumulant = TMath::Max(cumulant,0.+10e-10);
         if (fFlatNotGaussD) vec(ivar) = cumulant; 
         else {
            // sanity correction for out-of-range values
            Double_t maxErfInvArgRange = 0.99999999;
            Double_t arg = 2.0*cumulant - 1.0;
            arg = TMath::Min(+maxErfInvArgRange,arg);
            arg = TMath::Max(-maxErfInvArgRange,arg);
            
            vec(ivar) = 1.414213562*TMath::ErfInverse(arg);
         }
      }
   }
   
   if (fTransformedEvent==0 || fTransformedEvent->GetNVariables()!=ev->GetNVariables()) {
      if (fTransformedEvent!=0) { delete fTransformedEvent; fTransformedEvent = 0; }
      fTransformedEvent = new Event();
   }

   for (UInt_t itgt = 0; itgt < ev->GetNTargets(); itgt++) fTransformedEvent->SetTarget( itgt, ev->GetTarget(itgt) );
   for (UInt_t ivar=0; ivar<nvar; ivar++)                  fTransformedEvent->SetVal   ( ivar, vec(ivar) );

   fTransformedEvent->SetWeight     ( ev->GetWeight() );
   fTransformedEvent->SetBoostWeight( ev->GetBoostWeight() );
   fTransformedEvent->SetClass      ( ev->GetClass() );
   fTransformedEvent->SetSignalClass( ev->GetSignalClass() );
   return fTransformedEvent;
}

//_______________________________________________________________________
const TMVA::Event* TMVA::VariableGaussTransform::InverseTransform( const Event* const ev, Int_t cls ) const
{
   // apply the Gauss transformation
   // TODO: implementation of inverse transformation
   Log() << kFATAL << "Inverse transformation for Gauss transformation not yet implemented. Hence, this transformation cannot be applied together with regression. Please contact the authors if necessary." << Endl;

   if (!IsCreated())
      Log() << kFATAL << "Transformation not yet created" 
              << Endl;

   if (cls <0 || cls >= GetNClasses() ) cls = GetNClasses();
   if (GetNClasses() == 1 ) cls = 0;

   // get the variable vector of the current event
   const UInt_t nvar = GetNVariables();
   TVectorD vec( nvar );
   for (UInt_t ivar=0; ivar<nvar; ivar++) vec(ivar) = ev->GetVal(ivar);
   for (UInt_t ivar=0; ivar<nvar; ivar++) {
      if (0 != fCumulativeDist[ivar][cls]) { 
         // first make it flat
         Int_t    thebin   = (fCumulativeDist[ivar][cls])->FindBin(vec(ivar));
         Double_t cumulant = (fCumulativeDist[ivar][cls])->GetBinContent(thebin);
         // now transfor to a gaussian
         // actually, the "sqrt(2) is not really necessary, who cares if it is totally normalised
         //            vec(ivar) =  TMath::Sqrt(2.)*TMath::ErfInverse(2*sum - 1);
         if (fFlatNotGaussD) vec(ivar) = cumulant; 
         else {
            // sanity correction for out-of-range values
            Double_t maxErfInvArgRange = 0.99999999;
            Double_t arg = 2.0*cumulant - 1.0;
            arg = TMath::Min(+maxErfInvArgRange,arg);
            arg = TMath::Max(-maxErfInvArgRange,arg);
            
            vec(ivar) = 1.414213562*TMath::ErfInverse(arg);
         }
      }
   }
   
   if (fBackTransformedEvent==0 || fBackTransformedEvent->GetNVariables()!=ev->GetNVariables()) {
      if (fBackTransformedEvent!=0) { delete fBackTransformedEvent; fBackTransformedEvent = 0; }
      fBackTransformedEvent = new Event( *ev );
   }

   for (UInt_t itgt = 0; itgt < ev->GetNTargets(); itgt++) fBackTransformedEvent->SetTarget( itgt, ev->GetTarget(itgt) );
   for (UInt_t ivar=0; ivar<nvar; ivar++)                  fBackTransformedEvent->SetVal   ( ivar, vec(ivar) );

   fBackTransformedEvent->SetWeight     ( ev->GetWeight() );
   fBackTransformedEvent->SetBoostWeight( ev->GetBoostWeight() );
   fBackTransformedEvent->SetClass      ( ev->GetClass() );

   return fBackTransformedEvent;
}

//_______________________________________________________________________
void TMVA::VariableGaussTransform::GetCumulativeDist( const std::vector<Event*>& events )
{
   // fill the cumulative distributions

   const UInt_t nvar = GetNVariables();
   UInt_t nevt = events.size();
   
   const UInt_t nClasses = GetNClasses();
   UInt_t numDist  = nClasses+1; // calculate cumulative distributions for all "event" classes seperately + one where all classes are treated (added) together
      
   if (GetNClasses() == 1 ) numDist = nClasses; // for regression, if there is only one class, there is no "sum" of classes, hence 
 
   UInt_t **nbins = new UInt_t*[numDist];

   std::list< TMVA::TMVAGaussPair >  **listsForBinning = new std::list<TMVA::TMVAGaussPair>* [numDist];
   std::vector< Float_t >   **vsForBinning = new std::vector<Float_t>* [numDist];
   for (UInt_t i=0; i < numDist; i++) {
      listsForBinning[i] = new std::list<TMVA::TMVAGaussPair> [nvar];
      vsForBinning[i]    = new std::vector<Float_t> [nvar];
      nbins[i] = new UInt_t[nvar];  // nbins[0] = number of bins for signal distributions. It depends on the number of entries, thus it's the same for all the input variables, but it isn't necessary for some "weird" reason.
   }


   // perform event loop
   Float_t *sumOfWeights = new Float_t[numDist]; 
   Float_t *minWeight = new Float_t[numDist]; 
   Float_t *maxWeight = new Float_t[numDist]; 
   for (UInt_t i=0; i<numDist; i++) {
      sumOfWeights[i]=0;
      minWeight[i]=10E10;
      maxWeight[i]=0;
   }
   for (UInt_t ievt=0; ievt < nevt; ievt++) {
      const Event* ev= events[ievt];
      Int_t cls = ev->GetClass();
      sumOfWeights[cls] += ev->GetWeight();
      if (minWeight[cls] > ev->GetWeight()) minWeight[cls]=ev->GetWeight();
      if (maxWeight[cls] < ev->GetWeight()) maxWeight[cls]=ev->GetWeight();
      if (numDist>1) sumOfWeights[numDist-1] += ev->GetWeight();
      for (UInt_t ivar=0; ivar<nvar; ivar++) {
         listsForBinning[cls][ivar].push_back(TMVA::TMVAGaussPair(ev->GetVal(ivar),ev->GetWeight()));  
         if (numDist>1)listsForBinning[numDist-1][ivar].push_back(TMVA::TMVAGaussPair(ev->GetVal(ivar),ev->GetWeight()));  
      }  
   }
   if (numDist > 1) {
      for (UInt_t icl=0; icl<numDist-1; icl++){
         minWeight[numDist-1] = TMath::Min(minWeight[icl],minWeight[numDist-1]);
         maxWeight[numDist-1] = TMath::Max(maxWeight[icl],maxWeight[numDist-1]);
      }
   }

   // Sorting the lists, getting nbins ...
   const UInt_t nevmin=10;  // minimum number of events per bin (to make sure we get reasonable distributions)
   const UInt_t nbinsmax=2000; // maximum number of bins

   for (UInt_t icl=0; icl< numDist; icl++){
      for (UInt_t ivar=0; ivar<nvar; ivar++) {
         listsForBinning[icl][ivar].sort();  
         std::list< TMVA::TMVAGaussPair >::iterator it;
         Float_t sumPerBin = sumOfWeights[icl]/nbinsmax;
         sumPerBin=TMath::Max(minWeight[icl]*nevmin,sumPerBin);
         Float_t sum=0;
         Float_t ev_value=listsForBinning[icl][ivar].begin()->GetValue();
         Float_t lastev_value=ev_value;
         vsForBinning[icl][ivar].push_back(ev_value);

         for (it=listsForBinning[icl][ivar].begin(); it != listsForBinning[icl][ivar].end(); it++){
            sum+= it->GetWeight();
            if (sum >= sumPerBin) {
               ev_value=it->GetValue();
               if (ev_value>lastev_value) {   // protection against bin width of 0
                  vsForBinning[icl][ivar].push_back(ev_value);
                  sum = 0.;
                  lastev_value=ev_value;
               }
            }
         }
         if (sum!=0) vsForBinning[icl][ivar].push_back(listsForBinning[icl][ivar].back().GetValue()); 
         nbins[icl][ivar] = vsForBinning[icl][ivar].size();
      }
   }

   delete[] sumOfWeights;
   delete[] minWeight;
   delete[] maxWeight;

   // create histogram for the cumulative distribution.
   fCumulativeDist.resize(nvar);
   for (UInt_t icls = 0; icls < numDist; icls++) {
      for (UInt_t ivar=0; ivar < nvar; ivar++){
         Float_t* binnings = new Float_t[nbins[icls][ivar]];
         //the binning for this particular histogram:
         for (UInt_t k =0 ; k < nbins[icls][ivar]; k++){
            binnings[k] = vsForBinning[icls][ivar][k];
         }
         fCumulativeDist[ivar].resize(numDist);         
         if (0 != fCumulativeDist[ivar][icls] ) {
            delete fCumulativeDist[ivar][icls]; 
         }
         fCumulativeDist[ivar][icls] = new TH1F(Form("Cumulative_Var%d_cls%d",ivar,icls),
                                                Form("Cumulative_Var%d_cls%d",ivar,icls),
                                                nbins[icls][ivar] -1, // class icls
                                                binnings);
         fCumulativeDist[ivar][icls]->SetDirectory(0);
         delete [] binnings;
      }
   }
   
   // Deallocation
   for (UInt_t i=0; i<numDist; i++) {
      delete [] listsForBinning[numDist-i-1];
      delete [] vsForBinning[numDist-i-1];
      delete [] nbins[numDist-i-1];
   }
   delete [] listsForBinning;
   delete [] vsForBinning;
   delete [] nbins;

   // perform event loop
   std::vector<Int_t> ic(numDist);
   for (UInt_t ievt=0; ievt<nevt; ievt++) {
      
      const Event* ev= events[ievt];
      Int_t cls = ev->GetClass();
      
      for (UInt_t ivar=0; ivar<nvar; ivar++) {
         fCumulativeDist[ivar][cls]->Fill(ev->GetVal(ivar),ev->GetWeight());;               
         if (numDist>1) fCumulativeDist[ivar][numDist-1]->Fill(ev->GetVal(ivar),ev->GetWeight());;               
      }
   }         
   
   // clean up 
   CleanUpCumulativeArrays("PDF");

   // now sum up in order to get the real cumulative distribution   
   Double_t  sum = 0, total=0;
   for (UInt_t ivar=0; ivar<nvar; ivar++) {
      fCumulativePDF.resize(ivar+1);
      for (UInt_t icls=0; icls<numDist; icls++) {      
         (fCumulativeDist[ivar][icls])->Smooth(); 
         sum = 0;
         total = 0.;
         for (Int_t ibin=1; ibin <=fCumulativeDist[ivar][icls]->GetNbinsX() ; ibin++){
            Float_t val = (fCumulativeDist[ivar][icls])->GetBinContent(ibin);
            if (val>0) total += val;
         }
         for (Int_t ibin=1; ibin <=fCumulativeDist[ivar][icls]->GetNbinsX() ; ibin++){
            Float_t val = (fCumulativeDist[ivar][icls])->GetBinContent(ibin);
            if (val>0) sum += val;
            (fCumulativeDist[ivar][icls])->SetBinContent(ibin,sum/total);
         }
         // create PDf
         fCumulativePDF[ivar].push_back(new PDF( Form("GaussTransform var%d cls%d",ivar,icls),  fCumulativeDist[ivar][icls], PDF::kSpline2, fPdfMinSmooth, fPdfMaxSmooth,kFALSE,kFALSE));	 
      }
   }
}

//_______________________________________________________________________
void TMVA::VariableGaussTransform::WriteTransformationToStream( std::ostream& ) const
{
   Log() << kFATAL << "VariableGaussTransform::WriteTransformationToStream is obsolete" << Endl; 
}

//_______________________________________________________________________
void TMVA::VariableGaussTransform::CleanUpCumulativeArrays(TString opt) {
   // clean up of cumulative arrays
   if (opt == "ALL" || opt == "PDF"){ 
      for (UInt_t ivar=0; ivar<fCumulativePDF.size(); ivar++) {
	 for (UInt_t icls=0; icls<fCumulativePDF[ivar].size(); icls++) { 
	    if (0 != fCumulativePDF[ivar][icls]) delete fCumulativePDF[ivar][icls];
	 }
      }
      fCumulativePDF.clear();
   }
   if (opt == "ALL" || opt == "Dist"){ 
      for (UInt_t ivar=0; ivar<fCumulativeDist.size(); ivar++) {
	 for (UInt_t icls=0; icls<fCumulativeDist[ivar].size(); icls++) { 
	    if (0 != fCumulativeDist[ivar][icls]) delete fCumulativeDist[ivar][icls];
	 }
      }
      fCumulativeDist.clear();
   }
}
//_______________________________________________________________________
void TMVA::VariableGaussTransform::AttachXMLTo(void* parent) {
   // create XML description of Gauss transformation
   void* trfxml = gTools().xmlengine().NewChild(parent, 0, "Transform");
   gTools().AddAttr(trfxml, "Name",        "Gauss");
   gTools().AddAttr(trfxml, "FlatOrGauss", (fFlatNotGaussD?"Flat":"Gauss") );

   for (UInt_t ivar=0; ivar<GetNVariables(); ivar++) {
      void* varxml = gTools().xmlengine().NewChild( trfxml, 0, "Variable");
      gTools().AddAttr( varxml, "Name",     Variables()[ivar].GetLabel() );
      gTools().AddAttr( varxml, "VarIndex", ivar );
         
      if ( fCumulativePDF[ivar][0]==0 || fCumulativePDF[ivar][1]==0 )
         Log() << kFATAL << "Cumulative histograms for variable " << ivar << " don't exist, can't write it to weight file" << Endl;
      
      for (UInt_t icls=0; icls<fCumulativePDF[ivar].size(); icls++){
         void* pdfxml = gTools().xmlengine().NewChild( varxml, 0, Form("CumulativePDF_cls%d",icls));
	 (fCumulativePDF[ivar][icls])->AddXMLTo(pdfxml);
      }
   }
}

//_______________________________________________________________________
void TMVA::VariableGaussTransform::ReadFromXML( void* trfnode ) {
   // Read the transformation matrices from the xml node

   // clean up first
   CleanUpCumulativeArrays();

   gTools().ReadAttr(trfnode, "FlatOrGauss", fFlatNotGaussD );

   // Read the cumulative distribution
   void* varnode = gTools().xmlengine().GetChild( trfnode );

   TString varname, histname, classname;
   UInt_t ivar;
   while(varnode) {
      gTools().ReadAttr(varnode, "Name", varname);
      gTools().ReadAttr(varnode, "VarIndex", ivar);
      
      void* clsnode = gTools().xmlengine().GetChild( varnode);

      while(clsnode) {
	 void* pdfnode = gTools().xmlengine().GetChild( clsnode);
	 PDF* pdfToRead = new PDF(TString("tempName"),kFALSE);
	 pdfToRead->ReadXML(pdfnode); // pdfnode
	 // push_back PDF
	 fCumulativePDF.resize( ivar+1 );
	 fCumulativePDF[ivar].push_back(pdfToRead);
         clsnode = gTools().xmlengine().GetNext(clsnode);
      }
      
      varnode = gTools().xmlengine().GetNext(varnode);    
   }
   SetCreated();
}

//_______________________________________________________________________
void TMVA::VariableGaussTransform::ReadTransformationFromStream( std::istream& istr )
{
   Log() << kFATAL << "VariableGaussTransform::ReadTransformationFromStream: reading text files is obsolete" << Endl;
   // Read the cumulative distribution
   Bool_t addDirStatus = TH1::AddDirectoryStatus();
   TH1::AddDirectory(0); // this avoids the binding of the hists in TMVA::PDF to the current ROOT file
   char buf[512];
   istr.getline(buf,512);

   TString strvar, dummy;

   Int_t type;
   Int_t ivar;

   while (!(buf[0]=='#'&& buf[1]=='#')) { // if line starts with ## return
      char* p = buf;
      while (*p==' ' || *p=='\t') p++; // 'remove' leading whitespace
      if (*p=='#' || *p=='\0') {
         istr.getline(buf,512);
         continue; // if comment or empty line, read the next line
      }
      std::stringstream sstr(buf);
      sstr >> strvar;
      
      if (strvar=="CumulativeHistogram") {
         TString devnullS;
         Int_t   nbins;
         Float_t xmin, xmax;
         TString hname="";

         sstr  >> type >> ivar >> hname >> nbins >> xmin >> xmax; 

         TH1F * histToRead = fCumulativeDist[ivar][type];
         if ( histToRead !=0 ) delete histToRead;
         // recreate the cumulative histogram to be filled with the values read
         histToRead = new TH1F( hname, hname, nbins, xmin, xmax );
         histToRead->SetDirectory(0);
         fCumulativeDist[ivar][type]=histToRead;
         Float_t val;
         istr >> devnullS; // read the line "BinContent" .. 
         for (Int_t ibin=0; ibin<nbins; ibin++) {
            istr >> val;
            histToRead->SetBinContent(ibin+1,val);
            histToRead->SetBinContent(ibin+1,val);
         }
      } 
      if (strvar=="TransformToFlatInsteadOfGaussD=") { sstr >> fFlatNotGaussD; }

      istr.getline(buf,512); // reading the next line   
   }
   TH1::AddDirectory(addDirStatus);
   
   SetCreated();

}

//_______________________________________________________________________
void TMVA::VariableGaussTransform::PrintTransformation( ostream& ) 
{
   // prints the transformation 
   Int_t cls = 0;
   Log() << kINFO << "I do not know yet how to print this... look in the weight file " << cls << ":" << Endl;
   cls++;
}

//_______________________________________________________________________
void TMVA::VariableGaussTransform::MakeFunction( std::ostream& fout, const TString& fcncName, 
                                                 Int_t part, UInt_t trCounter, Int_t ) 
{
   // creates the transformation function
   //
   const UInt_t nvar = GetNVariables();
   UInt_t numDist  = GetNClasses() + 1;
   Int_t nBins = 1000; 
   // creates the gauss transformation function
   if (part==1) {
      fout << std::endl;
      // declare variables
      fout << "   double  cumulativeDist["<<nvar<<"]["<<numDist<<"]["<<nBins+1<<"];"<<std::endl;
      fout << "   double xmin["<<nvar<<"]["<<numDist<<"];"<<std::endl;
      fout << "   double xmax["<<nvar<<"]["<<numDist<<"];"<<std::endl;
   }
   if (part==2) {
      fout << std::endl;
      fout << "//_______________________________________________________________________" << std::endl;
      fout << "inline void " << fcncName << "::InitTransform_"<<trCounter<<"()" << std::endl;
      fout << "{" << std::endl;
      // fill meat here
      // loop over nvar , cls, loop over nBins
      // fill cumulativeDist with fCumulativePDF[ivar][cls])->GetVal(vec(ivar)
      for (UInt_t icls=0; icls<numDist; icls++) {
         for (UInt_t ivar=0; ivar<nvar; ivar++) {
	    Double_t xmn=Variables()[ivar].GetMin();
	    Double_t xmx=Variables()[ivar].GetMax();
	    fout << "    xmin["<<ivar<<"]["<<icls<<"]="<<xmn<<";"<<std::endl;
	    fout << "    xmax["<<ivar<<"]["<<icls<<"]="<<xmx<<";"<<std::endl;
            for (Int_t ibin=0; ibin<=nBins; ibin++) {
	       Double_t xval = xmn + (xmx-xmn) / nBins * ibin;
	       // ibin = (xval -xmin) / (xmax-xmin) *1000 
               fout << "  cumulativeDist[" << ivar << "]["<< icls<< "]["<<ibin<<"]="<< (fCumulativePDF[ivar][icls])->GetVal(xval)<< ";"<<std::endl;
	    }
	 }
      }
      fout << "}" << std::endl;
      fout << std::endl;
      fout << "//_______________________________________________________________________" << std::endl;
      fout << "inline void " << fcncName << "::Transform_"<<trCounter<<"( std::vector<double>& iv, int cls) const" << std::endl;
      fout << "{" << std::endl;
      fout << "   if (cls < 0 || cls > "<<GetNClasses()<<") {"<< std::endl;
      fout << "       if ("<<GetNClasses()<<" > 1 ) cls = "<<GetNClasses()<<";"<< std::endl;
      fout << "       else cls = "<<(fCumulativePDF[0].size()==1?0:2)<<";"<< std::endl;
      fout << "   }"<< std::endl;
      
      fout << "   bool FlatNotGaussD = "<< (fFlatNotGaussD? "true": "false") <<";"<< std::endl;
      fout << "   double cumulant;"<< std::endl;
      fout << "   const int nvar = "<<GetNVariables()<<";"<< std::endl;
      fout << "   for (int ivar=0; ivar<nvar; ivar++) {"<< std::endl;
      // ibin = (xval -xmin) / (xmax-xmin) *1000 
      fout << "   int ibin1 = (int) ((iv[ivar]-xmin[ivar][cls])/(xmax[ivar][cls]-xmin[ivar][cls])*"<<nBins<<");"<<std::endl;
      fout << "   if (ibin1<=0) { cumulant = cumulativeDist[ivar][cls][0];}"<<std::endl;
      fout << "   else if (ibin1>="<<nBins<<") { cumulant = cumulativeDist[ivar][cls]["<<nBins<<"];}"<<std::endl;
      fout << "   else {"<<std::endl;
      fout << "           int ibin2 = ibin1+1;" << std::endl;
      fout << "           double dx = iv[ivar]-(xmin[ivar][cls]+"<< (1./nBins)
	   << "           * ibin1* (xmax[ivar][cls]-xmin[ivar][cls]));"  
	   << std::endl;
      fout << "           double eps=dx/(xmax[ivar][cls]-xmin[ivar][cls])*"<<nBins<<";"<<std::endl;	 
      fout << "           cumulant = eps*cumulativeDist[ivar][cls][ibin1] + (1-eps)*cumulativeDist[ivar][cls][ibin2];" << std::endl;
      fout << "           if (cumulant>1.-10e-10) cumulant = 1.-10e-10;"<< std::endl;
      fout << "           if (cumulant<10e-10)    cumulant = 10e-10;"<< std::endl;
      fout << "           if (FlatNotGaussD) iv[ivar] = cumulant;"<< std::endl;
      fout << "           else {"<< std::endl;
      fout << "              double maxErfInvArgRange = 0.99999999;"<< std::endl;
      fout << "              double arg = 2.0*cumulant - 1.0;"<< std::endl;
      fout << "              if (arg >  maxErfInvArgRange) arg= maxErfInvArgRange;"<< std::endl;
      fout << "              if (arg < -maxErfInvArgRange) arg=-maxErfInvArgRange;"<< std::endl;
      fout << "              double inverf=0., stp=1. ;"<<std::endl;
      fout << "              while (stp >1.e-10){;"<<std::endl;
      fout << "                if (erf(inverf)>arg) inverf -=stp ;"<<std::endl;
      fout << "                else if (erf(inverf)<=arg && erf(inverf+stp)>=arg) stp=stp/5. ;"<<std::endl;
      fout << "                else inverf += stp;"<<std::endl;
      fout << "              } ;"<<std::endl;
      fout << "              //iv[ivar] = 1.414213562*TMath::ErfInverse(arg);"<< std::endl;
      fout << "              iv[ivar] = 1.414213562* inverf;"<< std::endl;
      fout << "           }"<< std::endl;
      fout << "       }"<< std::endl;
      fout << "   }"<< std::endl;
      fout << "}" << std::endl;
   }
}
 VariableGaussTransform.cxx:1
 VariableGaussTransform.cxx:2
 VariableGaussTransform.cxx:3
 VariableGaussTransform.cxx:4
 VariableGaussTransform.cxx:5
 VariableGaussTransform.cxx:6
 VariableGaussTransform.cxx:7
 VariableGaussTransform.cxx:8
 VariableGaussTransform.cxx:9
 VariableGaussTransform.cxx:10
 VariableGaussTransform.cxx:11
 VariableGaussTransform.cxx:12
 VariableGaussTransform.cxx:13
 VariableGaussTransform.cxx:14
 VariableGaussTransform.cxx:15
 VariableGaussTransform.cxx:16
 VariableGaussTransform.cxx:17
 VariableGaussTransform.cxx:18
 VariableGaussTransform.cxx:19
 VariableGaussTransform.cxx:20
 VariableGaussTransform.cxx:21
 VariableGaussTransform.cxx:22
 VariableGaussTransform.cxx:23
 VariableGaussTransform.cxx:24
 VariableGaussTransform.cxx:25
 VariableGaussTransform.cxx:26
 VariableGaussTransform.cxx:27
 VariableGaussTransform.cxx:28
 VariableGaussTransform.cxx:29
 VariableGaussTransform.cxx:30
 VariableGaussTransform.cxx:31
 VariableGaussTransform.cxx:32
 VariableGaussTransform.cxx:33
 VariableGaussTransform.cxx:34
 VariableGaussTransform.cxx:35
 VariableGaussTransform.cxx:36
 VariableGaussTransform.cxx:37
 VariableGaussTransform.cxx:38
 VariableGaussTransform.cxx:39
 VariableGaussTransform.cxx:40
 VariableGaussTransform.cxx:41
 VariableGaussTransform.cxx:42
 VariableGaussTransform.cxx:43
 VariableGaussTransform.cxx:44
 VariableGaussTransform.cxx:45
 VariableGaussTransform.cxx:46
 VariableGaussTransform.cxx:47
 VariableGaussTransform.cxx:48
 VariableGaussTransform.cxx:49
 VariableGaussTransform.cxx:50
 VariableGaussTransform.cxx:51
 VariableGaussTransform.cxx:52
 VariableGaussTransform.cxx:53
 VariableGaussTransform.cxx:54
 VariableGaussTransform.cxx:55
 VariableGaussTransform.cxx:56
 VariableGaussTransform.cxx:57
 VariableGaussTransform.cxx:58
 VariableGaussTransform.cxx:59
 VariableGaussTransform.cxx:60
 VariableGaussTransform.cxx:61
 VariableGaussTransform.cxx:62
 VariableGaussTransform.cxx:63
 VariableGaussTransform.cxx:64
 VariableGaussTransform.cxx:65
 VariableGaussTransform.cxx:66
 VariableGaussTransform.cxx:67
 VariableGaussTransform.cxx:68
 VariableGaussTransform.cxx:69
 VariableGaussTransform.cxx:70
 VariableGaussTransform.cxx:71
 VariableGaussTransform.cxx:72
 VariableGaussTransform.cxx:73
 VariableGaussTransform.cxx:74
 VariableGaussTransform.cxx:75
 VariableGaussTransform.cxx:76
 VariableGaussTransform.cxx:77
 VariableGaussTransform.cxx:78
 VariableGaussTransform.cxx:79
 VariableGaussTransform.cxx:80
 VariableGaussTransform.cxx:81
 VariableGaussTransform.cxx:82
 VariableGaussTransform.cxx:83
 VariableGaussTransform.cxx:84
 VariableGaussTransform.cxx:85
 VariableGaussTransform.cxx:86
 VariableGaussTransform.cxx:87
 VariableGaussTransform.cxx:88
 VariableGaussTransform.cxx:89
 VariableGaussTransform.cxx:90
 VariableGaussTransform.cxx:91
 VariableGaussTransform.cxx:92
 VariableGaussTransform.cxx:93
 VariableGaussTransform.cxx:94
 VariableGaussTransform.cxx:95
 VariableGaussTransform.cxx:96
 VariableGaussTransform.cxx:97
 VariableGaussTransform.cxx:98
 VariableGaussTransform.cxx:99
 VariableGaussTransform.cxx:100
 VariableGaussTransform.cxx:101
 VariableGaussTransform.cxx:102
 VariableGaussTransform.cxx:103
 VariableGaussTransform.cxx:104
 VariableGaussTransform.cxx:105
 VariableGaussTransform.cxx:106
 VariableGaussTransform.cxx:107
 VariableGaussTransform.cxx:108
 VariableGaussTransform.cxx:109
 VariableGaussTransform.cxx:110
 VariableGaussTransform.cxx:111
 VariableGaussTransform.cxx:112
 VariableGaussTransform.cxx:113
 VariableGaussTransform.cxx:114
 VariableGaussTransform.cxx:115
 VariableGaussTransform.cxx:116
 VariableGaussTransform.cxx:117
 VariableGaussTransform.cxx:118
 VariableGaussTransform.cxx:119
 VariableGaussTransform.cxx:120
 VariableGaussTransform.cxx:121
 VariableGaussTransform.cxx:122
 VariableGaussTransform.cxx:123
 VariableGaussTransform.cxx:124
 VariableGaussTransform.cxx:125
 VariableGaussTransform.cxx:126
 VariableGaussTransform.cxx:127
 VariableGaussTransform.cxx:128
 VariableGaussTransform.cxx:129
 VariableGaussTransform.cxx:130
 VariableGaussTransform.cxx:131
 VariableGaussTransform.cxx:132
 VariableGaussTransform.cxx:133
 VariableGaussTransform.cxx:134
 VariableGaussTransform.cxx:135
 VariableGaussTransform.cxx:136
 VariableGaussTransform.cxx:137
 VariableGaussTransform.cxx:138
 VariableGaussTransform.cxx:139
 VariableGaussTransform.cxx:140
 VariableGaussTransform.cxx:141
 VariableGaussTransform.cxx:142
 VariableGaussTransform.cxx:143
 VariableGaussTransform.cxx:144
 VariableGaussTransform.cxx:145
 VariableGaussTransform.cxx:146
 VariableGaussTransform.cxx:147
 VariableGaussTransform.cxx:148
 VariableGaussTransform.cxx:149
 VariableGaussTransform.cxx:150
 VariableGaussTransform.cxx:151
 VariableGaussTransform.cxx:152
 VariableGaussTransform.cxx:153
 VariableGaussTransform.cxx:154
 VariableGaussTransform.cxx:155
 VariableGaussTransform.cxx:156
 VariableGaussTransform.cxx:157
 VariableGaussTransform.cxx:158
 VariableGaussTransform.cxx:159
 VariableGaussTransform.cxx:160
 VariableGaussTransform.cxx:161
 VariableGaussTransform.cxx:162
 VariableGaussTransform.cxx:163
 VariableGaussTransform.cxx:164
 VariableGaussTransform.cxx:165
 VariableGaussTransform.cxx:166
 VariableGaussTransform.cxx:167
 VariableGaussTransform.cxx:168
 VariableGaussTransform.cxx:169
 VariableGaussTransform.cxx:170
 VariableGaussTransform.cxx:171
 VariableGaussTransform.cxx:172
 VariableGaussTransform.cxx:173
 VariableGaussTransform.cxx:174
 VariableGaussTransform.cxx:175
 VariableGaussTransform.cxx:176
 VariableGaussTransform.cxx:177
 VariableGaussTransform.cxx:178
 VariableGaussTransform.cxx:179
 VariableGaussTransform.cxx:180
 VariableGaussTransform.cxx:181
 VariableGaussTransform.cxx:182
 VariableGaussTransform.cxx:183
 VariableGaussTransform.cxx:184
 VariableGaussTransform.cxx:185
 VariableGaussTransform.cxx:186
 VariableGaussTransform.cxx:187
 VariableGaussTransform.cxx:188
 VariableGaussTransform.cxx:189
 VariableGaussTransform.cxx:190
 VariableGaussTransform.cxx:191
 VariableGaussTransform.cxx:192
 VariableGaussTransform.cxx:193
 VariableGaussTransform.cxx:194
 VariableGaussTransform.cxx:195
 VariableGaussTransform.cxx:196
 VariableGaussTransform.cxx:197
 VariableGaussTransform.cxx:198
 VariableGaussTransform.cxx:199
 VariableGaussTransform.cxx:200
 VariableGaussTransform.cxx:201
 VariableGaussTransform.cxx:202
 VariableGaussTransform.cxx:203
 VariableGaussTransform.cxx:204
 VariableGaussTransform.cxx:205
 VariableGaussTransform.cxx:206
 VariableGaussTransform.cxx:207
 VariableGaussTransform.cxx:208
 VariableGaussTransform.cxx:209
 VariableGaussTransform.cxx:210
 VariableGaussTransform.cxx:211
 VariableGaussTransform.cxx:212
 VariableGaussTransform.cxx:213
 VariableGaussTransform.cxx:214
 VariableGaussTransform.cxx:215
 VariableGaussTransform.cxx:216
 VariableGaussTransform.cxx:217
 VariableGaussTransform.cxx:218
 VariableGaussTransform.cxx:219
 VariableGaussTransform.cxx:220
 VariableGaussTransform.cxx:221
 VariableGaussTransform.cxx:222
 VariableGaussTransform.cxx:223
 VariableGaussTransform.cxx:224
 VariableGaussTransform.cxx:225
 VariableGaussTransform.cxx:226
 VariableGaussTransform.cxx:227
 VariableGaussTransform.cxx:228
 VariableGaussTransform.cxx:229
 VariableGaussTransform.cxx:230
 VariableGaussTransform.cxx:231
 VariableGaussTransform.cxx:232
 VariableGaussTransform.cxx:233
 VariableGaussTransform.cxx:234
 VariableGaussTransform.cxx:235
 VariableGaussTransform.cxx:236
 VariableGaussTransform.cxx:237
 VariableGaussTransform.cxx:238
 VariableGaussTransform.cxx:239
 VariableGaussTransform.cxx:240
 VariableGaussTransform.cxx:241
 VariableGaussTransform.cxx:242
 VariableGaussTransform.cxx:243
 VariableGaussTransform.cxx:244
 VariableGaussTransform.cxx:245
 VariableGaussTransform.cxx:246
 VariableGaussTransform.cxx:247
 VariableGaussTransform.cxx:248
 VariableGaussTransform.cxx:249
 VariableGaussTransform.cxx:250
 VariableGaussTransform.cxx:251
 VariableGaussTransform.cxx:252
 VariableGaussTransform.cxx:253
 VariableGaussTransform.cxx:254
 VariableGaussTransform.cxx:255
 VariableGaussTransform.cxx:256
 VariableGaussTransform.cxx:257
 VariableGaussTransform.cxx:258
 VariableGaussTransform.cxx:259
 VariableGaussTransform.cxx:260
 VariableGaussTransform.cxx:261
 VariableGaussTransform.cxx:262
 VariableGaussTransform.cxx:263
 VariableGaussTransform.cxx:264
 VariableGaussTransform.cxx:265
 VariableGaussTransform.cxx:266
 VariableGaussTransform.cxx:267
 VariableGaussTransform.cxx:268
 VariableGaussTransform.cxx:269
 VariableGaussTransform.cxx:270
 VariableGaussTransform.cxx:271
 VariableGaussTransform.cxx:272
 VariableGaussTransform.cxx:273
 VariableGaussTransform.cxx:274
 VariableGaussTransform.cxx:275
 VariableGaussTransform.cxx:276
 VariableGaussTransform.cxx:277
 VariableGaussTransform.cxx:278
 VariableGaussTransform.cxx:279
 VariableGaussTransform.cxx:280
 VariableGaussTransform.cxx:281
 VariableGaussTransform.cxx:282
 VariableGaussTransform.cxx:283
 VariableGaussTransform.cxx:284
 VariableGaussTransform.cxx:285
 VariableGaussTransform.cxx:286
 VariableGaussTransform.cxx:287
 VariableGaussTransform.cxx:288
 VariableGaussTransform.cxx:289
 VariableGaussTransform.cxx:290
 VariableGaussTransform.cxx:291
 VariableGaussTransform.cxx:292
 VariableGaussTransform.cxx:293
 VariableGaussTransform.cxx:294
 VariableGaussTransform.cxx:295
 VariableGaussTransform.cxx:296
 VariableGaussTransform.cxx:297
 VariableGaussTransform.cxx:298
 VariableGaussTransform.cxx:299
 VariableGaussTransform.cxx:300
 VariableGaussTransform.cxx:301
 VariableGaussTransform.cxx:302
 VariableGaussTransform.cxx:303
 VariableGaussTransform.cxx:304
 VariableGaussTransform.cxx:305
 VariableGaussTransform.cxx:306
 VariableGaussTransform.cxx:307
 VariableGaussTransform.cxx:308
 VariableGaussTransform.cxx:309
 VariableGaussTransform.cxx:310
 VariableGaussTransform.cxx:311
 VariableGaussTransform.cxx:312
 VariableGaussTransform.cxx:313
 VariableGaussTransform.cxx:314
 VariableGaussTransform.cxx:315
 VariableGaussTransform.cxx:316
 VariableGaussTransform.cxx:317
 VariableGaussTransform.cxx:318
 VariableGaussTransform.cxx:319
 VariableGaussTransform.cxx:320
 VariableGaussTransform.cxx:321
 VariableGaussTransform.cxx:322
 VariableGaussTransform.cxx:323
 VariableGaussTransform.cxx:324
 VariableGaussTransform.cxx:325
 VariableGaussTransform.cxx:326
 VariableGaussTransform.cxx:327
 VariableGaussTransform.cxx:328
 VariableGaussTransform.cxx:329
 VariableGaussTransform.cxx:330
 VariableGaussTransform.cxx:331
 VariableGaussTransform.cxx:332
 VariableGaussTransform.cxx:333
 VariableGaussTransform.cxx:334
 VariableGaussTransform.cxx:335
 VariableGaussTransform.cxx:336
 VariableGaussTransform.cxx:337
 VariableGaussTransform.cxx:338
 VariableGaussTransform.cxx:339
 VariableGaussTransform.cxx:340
 VariableGaussTransform.cxx:341
 VariableGaussTransform.cxx:342
 VariableGaussTransform.cxx:343
 VariableGaussTransform.cxx:344
 VariableGaussTransform.cxx:345
 VariableGaussTransform.cxx:346
 VariableGaussTransform.cxx:347
 VariableGaussTransform.cxx:348
 VariableGaussTransform.cxx:349
 VariableGaussTransform.cxx:350
 VariableGaussTransform.cxx:351
 VariableGaussTransform.cxx:352
 VariableGaussTransform.cxx:353
 VariableGaussTransform.cxx:354
 VariableGaussTransform.cxx:355
 VariableGaussTransform.cxx:356
 VariableGaussTransform.cxx:357
 VariableGaussTransform.cxx:358
 VariableGaussTransform.cxx:359
 VariableGaussTransform.cxx:360
 VariableGaussTransform.cxx:361
 VariableGaussTransform.cxx:362
 VariableGaussTransform.cxx:363
 VariableGaussTransform.cxx:364
 VariableGaussTransform.cxx:365
 VariableGaussTransform.cxx:366
 VariableGaussTransform.cxx:367
 VariableGaussTransform.cxx:368
 VariableGaussTransform.cxx:369
 VariableGaussTransform.cxx:370
 VariableGaussTransform.cxx:371
 VariableGaussTransform.cxx:372
 VariableGaussTransform.cxx:373
 VariableGaussTransform.cxx:374
 VariableGaussTransform.cxx:375
 VariableGaussTransform.cxx:376
 VariableGaussTransform.cxx:377
 VariableGaussTransform.cxx:378
 VariableGaussTransform.cxx:379
 VariableGaussTransform.cxx:380
 VariableGaussTransform.cxx:381
 VariableGaussTransform.cxx:382
 VariableGaussTransform.cxx:383
 VariableGaussTransform.cxx:384
 VariableGaussTransform.cxx:385
 VariableGaussTransform.cxx:386
 VariableGaussTransform.cxx:387
 VariableGaussTransform.cxx:388
 VariableGaussTransform.cxx:389
 VariableGaussTransform.cxx:390
 VariableGaussTransform.cxx:391
 VariableGaussTransform.cxx:392
 VariableGaussTransform.cxx:393
 VariableGaussTransform.cxx:394
 VariableGaussTransform.cxx:395
 VariableGaussTransform.cxx:396
 VariableGaussTransform.cxx:397
 VariableGaussTransform.cxx:398
 VariableGaussTransform.cxx:399
 VariableGaussTransform.cxx:400
 VariableGaussTransform.cxx:401
 VariableGaussTransform.cxx:402
 VariableGaussTransform.cxx:403
 VariableGaussTransform.cxx:404
 VariableGaussTransform.cxx:405
 VariableGaussTransform.cxx:406
 VariableGaussTransform.cxx:407
 VariableGaussTransform.cxx:408
 VariableGaussTransform.cxx:409
 VariableGaussTransform.cxx:410
 VariableGaussTransform.cxx:411
 VariableGaussTransform.cxx:412
 VariableGaussTransform.cxx:413
 VariableGaussTransform.cxx:414
 VariableGaussTransform.cxx:415
 VariableGaussTransform.cxx:416
 VariableGaussTransform.cxx:417
 VariableGaussTransform.cxx:418
 VariableGaussTransform.cxx:419
 VariableGaussTransform.cxx:420
 VariableGaussTransform.cxx:421
 VariableGaussTransform.cxx:422
 VariableGaussTransform.cxx:423
 VariableGaussTransform.cxx:424
 VariableGaussTransform.cxx:425
 VariableGaussTransform.cxx:426
 VariableGaussTransform.cxx:427
 VariableGaussTransform.cxx:428
 VariableGaussTransform.cxx:429
 VariableGaussTransform.cxx:430
 VariableGaussTransform.cxx:431
 VariableGaussTransform.cxx:432
 VariableGaussTransform.cxx:433
 VariableGaussTransform.cxx:434
 VariableGaussTransform.cxx:435
 VariableGaussTransform.cxx:436
 VariableGaussTransform.cxx:437
 VariableGaussTransform.cxx:438
 VariableGaussTransform.cxx:439
 VariableGaussTransform.cxx:440
 VariableGaussTransform.cxx:441
 VariableGaussTransform.cxx:442
 VariableGaussTransform.cxx:443
 VariableGaussTransform.cxx:444
 VariableGaussTransform.cxx:445
 VariableGaussTransform.cxx:446
 VariableGaussTransform.cxx:447
 VariableGaussTransform.cxx:448
 VariableGaussTransform.cxx:449
 VariableGaussTransform.cxx:450
 VariableGaussTransform.cxx:451
 VariableGaussTransform.cxx:452
 VariableGaussTransform.cxx:453
 VariableGaussTransform.cxx:454
 VariableGaussTransform.cxx:455
 VariableGaussTransform.cxx:456
 VariableGaussTransform.cxx:457
 VariableGaussTransform.cxx:458
 VariableGaussTransform.cxx:459
 VariableGaussTransform.cxx:460
 VariableGaussTransform.cxx:461
 VariableGaussTransform.cxx:462
 VariableGaussTransform.cxx:463
 VariableGaussTransform.cxx:464
 VariableGaussTransform.cxx:465
 VariableGaussTransform.cxx:466
 VariableGaussTransform.cxx:467
 VariableGaussTransform.cxx:468
 VariableGaussTransform.cxx:469
 VariableGaussTransform.cxx:470
 VariableGaussTransform.cxx:471
 VariableGaussTransform.cxx:472
 VariableGaussTransform.cxx:473
 VariableGaussTransform.cxx:474
 VariableGaussTransform.cxx:475
 VariableGaussTransform.cxx:476
 VariableGaussTransform.cxx:477
 VariableGaussTransform.cxx:478
 VariableGaussTransform.cxx:479
 VariableGaussTransform.cxx:480
 VariableGaussTransform.cxx:481
 VariableGaussTransform.cxx:482
 VariableGaussTransform.cxx:483
 VariableGaussTransform.cxx:484
 VariableGaussTransform.cxx:485
 VariableGaussTransform.cxx:486
 VariableGaussTransform.cxx:487
 VariableGaussTransform.cxx:488
 VariableGaussTransform.cxx:489
 VariableGaussTransform.cxx:490
 VariableGaussTransform.cxx:491
 VariableGaussTransform.cxx:492
 VariableGaussTransform.cxx:493
 VariableGaussTransform.cxx:494
 VariableGaussTransform.cxx:495
 VariableGaussTransform.cxx:496
 VariableGaussTransform.cxx:497
 VariableGaussTransform.cxx:498
 VariableGaussTransform.cxx:499
 VariableGaussTransform.cxx:500
 VariableGaussTransform.cxx:501
 VariableGaussTransform.cxx:502
 VariableGaussTransform.cxx:503
 VariableGaussTransform.cxx:504
 VariableGaussTransform.cxx:505
 VariableGaussTransform.cxx:506
 VariableGaussTransform.cxx:507
 VariableGaussTransform.cxx:508
 VariableGaussTransform.cxx:509
 VariableGaussTransform.cxx:510
 VariableGaussTransform.cxx:511
 VariableGaussTransform.cxx:512
 VariableGaussTransform.cxx:513
 VariableGaussTransform.cxx:514
 VariableGaussTransform.cxx:515
 VariableGaussTransform.cxx:516
 VariableGaussTransform.cxx:517
 VariableGaussTransform.cxx:518
 VariableGaussTransform.cxx:519
 VariableGaussTransform.cxx:520
 VariableGaussTransform.cxx:521
 VariableGaussTransform.cxx:522
 VariableGaussTransform.cxx:523
 VariableGaussTransform.cxx:524
 VariableGaussTransform.cxx:525
 VariableGaussTransform.cxx:526
 VariableGaussTransform.cxx:527
 VariableGaussTransform.cxx:528
 VariableGaussTransform.cxx:529
 VariableGaussTransform.cxx:530
 VariableGaussTransform.cxx:531
 VariableGaussTransform.cxx:532
 VariableGaussTransform.cxx:533
 VariableGaussTransform.cxx:534
 VariableGaussTransform.cxx:535
 VariableGaussTransform.cxx:536
 VariableGaussTransform.cxx:537
 VariableGaussTransform.cxx:538
 VariableGaussTransform.cxx:539
 VariableGaussTransform.cxx:540
 VariableGaussTransform.cxx:541
 VariableGaussTransform.cxx:542
 VariableGaussTransform.cxx:543
 VariableGaussTransform.cxx:544
 VariableGaussTransform.cxx:545
 VariableGaussTransform.cxx:546
 VariableGaussTransform.cxx:547
 VariableGaussTransform.cxx:548
 VariableGaussTransform.cxx:549
 VariableGaussTransform.cxx:550
 VariableGaussTransform.cxx:551
 VariableGaussTransform.cxx:552
 VariableGaussTransform.cxx:553
 VariableGaussTransform.cxx:554
 VariableGaussTransform.cxx:555
 VariableGaussTransform.cxx:556
 VariableGaussTransform.cxx:557
 VariableGaussTransform.cxx:558
 VariableGaussTransform.cxx:559
 VariableGaussTransform.cxx:560
 VariableGaussTransform.cxx:561
 VariableGaussTransform.cxx:562
 VariableGaussTransform.cxx:563
 VariableGaussTransform.cxx:564
 VariableGaussTransform.cxx:565
 VariableGaussTransform.cxx:566
 VariableGaussTransform.cxx:567
 VariableGaussTransform.cxx:568
 VariableGaussTransform.cxx:569
 VariableGaussTransform.cxx:570
 VariableGaussTransform.cxx:571
 VariableGaussTransform.cxx:572
 VariableGaussTransform.cxx:573
 VariableGaussTransform.cxx:574
 VariableGaussTransform.cxx:575
 VariableGaussTransform.cxx:576
 VariableGaussTransform.cxx:577
 VariableGaussTransform.cxx:578
 VariableGaussTransform.cxx:579
 VariableGaussTransform.cxx:580
 VariableGaussTransform.cxx:581
 VariableGaussTransform.cxx:582
 VariableGaussTransform.cxx:583
 VariableGaussTransform.cxx:584
 VariableGaussTransform.cxx:585
 VariableGaussTransform.cxx:586
 VariableGaussTransform.cxx:587
 VariableGaussTransform.cxx:588
 VariableGaussTransform.cxx:589
 VariableGaussTransform.cxx:590
 VariableGaussTransform.cxx:591
 VariableGaussTransform.cxx:592
 VariableGaussTransform.cxx:593
 VariableGaussTransform.cxx:594
 VariableGaussTransform.cxx:595
 VariableGaussTransform.cxx:596
 VariableGaussTransform.cxx:597
 VariableGaussTransform.cxx:598
 VariableGaussTransform.cxx:599
 VariableGaussTransform.cxx:600
 VariableGaussTransform.cxx:601
 VariableGaussTransform.cxx:602