ROOT logo
// @(#)root/tmva $Id$
// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Peter Speckmayer, Eckhard von Toerne

/**********************************************************************************
 * Project: TMVA - a Root-integrated toolkit for multivariate data analysis       *
 * Package: TMVA                                                                  *
 * Class  : VariableNormalizeTransform                                            *
 * 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           *
 *      Peter Speckmayer <Peter.Speckmayer@cern.ch> - CERN, Switzerland           *
 *      Helge Voss       <Helge.Voss@cern.ch>       - MPI-K Heidelberg, Germany   *
 *      Eckhard v. Toerne     <evt@uni-bonn.de>        - U of Bonn, Germany       *
 *                                                                                *
 * Copyright (c) 2005-2011:                                                       *
 *      CERN, Switzerland                                                         *
 *      MPI-K Heidelberg, Germany                                                 *
 *      U. of Bonn, 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)                                          *
 **********************************************************************************/

#include <iostream>
#include <iomanip>

#include "TVectorF.h"
#include "TVectorD.h"
#include "TMatrixD.h"
#include "TMatrixDBase.h"

#ifndef ROOT_TMVA_MsgLogger
#include "TMVA/MsgLogger.h"
#endif
#ifndef ROOT_TMVA_VariableNormalizeTransform
#include "TMVA/VariableNormalizeTransform.h"
#endif
#ifndef ROOT_TMVA_Tools
#include "TMVA/Tools.h"
#endif
#ifndef ROOT_TMVA_DataSet
#include "TMVA/DataSet.h"
#endif

ClassImp(TMVA::VariableNormalizeTransform)

//_______________________________________________________________________
TMVA::VariableNormalizeTransform::VariableNormalizeTransform( DataSetInfo& dsi )
: VariableTransformBase( dsi, Types::kNormalized, "Norm" )
{ 
   // constructor
}

//_______________________________________________________________________
TMVA::VariableNormalizeTransform::~VariableNormalizeTransform() {
}

//_______________________________________________________________________
void TMVA::VariableNormalizeTransform::Initialize()
{
   // initialization of the normalization transformation

   UInt_t inputSize = fGet.size();
   Int_t numC = GetNClasses()+1;
   if (GetNClasses() <= 1 ) numC = 1;

   fMin.resize( numC ); 
   fMax.resize( numC ); 
   for (Int_t i=0; i<numC; i++) {
      fMin.at(i).resize(inputSize);
      fMax.at(i).resize(inputSize);
      fMin.at(i).assign(inputSize, 0);
      fMax.at(i).assign(inputSize, 0);
   }
}

//_______________________________________________________________________
Bool_t TMVA::VariableNormalizeTransform::PrepareTransformation (const std::vector<Event*>& events)
{
   // prepare transformation
   if (!IsEnabled() || IsCreated()) return kTRUE;

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

   Initialize();

   CalcNormalizationParams( events );

   SetCreated( kTRUE );

   return kTRUE;
}

//_______________________________________________________________________
const TMVA::Event* TMVA::VariableNormalizeTransform::Transform( const TMVA::Event* const ev, Int_t cls ) const
{

   // apply the normalization transformation
   if (!IsCreated()) Log() << kFATAL << "Transformation not yet created" << Endl;

   // if cls (the class chosen by the user) not existing, 
   // assume that he wants to have the matrix for all classes together. 
   // if (cls < 0 || cls > GetNClasses()) {
   //       if (GetNClasses() > 1 ) cls = GetNClasses();
   //       else cls = (fMin.size()==1?0:2);
   //    }
   // EVT this is a workaround to address the reader problem with transforma and EvaluateMVA(std::vector<float/double> ,...) 
   if (cls < 0 || cls >= (int) fMin.size()) cls = fMin.size()-1;
   // EVT workaround end

   FloatVector input; // will be filled with the selected variables, targets, (spectators)
   FloatVector output; // will be filled with the selected variables, targets, (spectators)
   std::vector<Char_t> mask; // entries with kTRUE must not be transformed
   GetInput( ev, input, mask );

   if (fTransformedEvent==0) fTransformedEvent = new Event();

   Float_t min,max;
   const FloatVector& minVector = fMin.at(cls); 
   const FloatVector& maxVector = fMax.at(cls);
   
   UInt_t iidx = 0;          
   std::vector<Char_t>::iterator itMask = mask.begin();
   for ( std::vector<Float_t>::iterator itInp = input.begin(), itInpEnd = input.end(); itInp != itInpEnd; ++itInp) { // loop over input variables
      if( (*itMask) ){
         ++iidx;
         ++itMask;
         // don't put any value into output if the value is masked
         continue;
      }

      Float_t val = (*itInp);

      min = minVector.at(iidx); 
      max = maxVector.at(iidx);
      Float_t offset = min;
      Float_t scale  = 1.0/(max-min);

      Float_t valnorm = (val-offset)*scale * 2 - 1;
      output.push_back( valnorm );

      ++iidx;
      ++itMask;
   }
   
   SetOutput( fTransformedEvent, output, mask, ev );
   return fTransformedEvent;
}

//_______________________________________________________________________
const TMVA::Event* TMVA::VariableNormalizeTransform::InverseTransform(const TMVA::Event* const ev, Int_t cls ) const
{
   // apply the inverse transformation
   if (!IsCreated()) Log() << kFATAL << "Transformation not yet created" << Endl;

   // if cls (the class chosen by the user) not existing, 
   // assume that user wants to have the transformation for all classes together. 
   if (cls < 0 || cls > GetNClasses()) {
      if (GetNClasses() > 1 ) cls = GetNClasses();
      else cls = 0;
   }

   FloatVector input;  // will be filled with the selected variables, targets, (spectators)
   FloatVector output; // will be filled with the output
   std::vector<Char_t> mask;
   GetInput( ev, input, mask, kTRUE );

   if (fBackTransformedEvent==0) fBackTransformedEvent = new Event( *ev );

   Float_t min,max;
   const FloatVector& minVector = fMin.at(cls); 
   const FloatVector& maxVector = fMax.at(cls);
   
   UInt_t iidx = 0;          
   for ( std::vector<Float_t>::iterator itInp = input.begin(), itInpEnd = input.end(); itInp != itInpEnd; ++itInp) { // loop over input variables
      Float_t val = (*itInp);

      min = minVector.at(iidx); 
      max = maxVector.at(iidx);
      Float_t offset = min;
      Float_t scale  = 1.0/(max-min);

      Float_t valnorm = offset+((val+1)/(scale * 2));
      output.push_back( valnorm );

      ++iidx;
   }

   SetOutput( fBackTransformedEvent, output, mask, ev, kTRUE );

   return fBackTransformedEvent;
}

//_______________________________________________________________________
void TMVA::VariableNormalizeTransform::CalcNormalizationParams( const std::vector< Event*>& events )
{
   // compute offset and scale from min and max
   if (events.size() <= 1) 
      Log() << kFATAL << "Not enough events (found " << events.size() << ") to calculate the normalization" << Endl;
   
   FloatVector input; // will be filled with the selected variables, targets, (spectators)
   std::vector<Char_t> mask;

   UInt_t inputSize = fGet.size(); // number of input variables

   const UInt_t nCls = GetNClasses();
   Int_t numC = nCls+1;   // prepare the min and max values for each of the classes and additionally for all classes (if more than one)
   Int_t all = nCls; // at idx the min and max values for "all" classes are stored
   if (nCls <= 1 ) {
      numC = 1;
      all = 0;
   }

   for (UInt_t iinp=0; iinp<inputSize; ++iinp) {
      for (Int_t ic = 0; ic < numC; ic++) {
         fMin.at(ic).at(iinp) = FLT_MAX;
         fMax.at(ic).at(iinp) = -FLT_MAX;
      }
   }

   std::vector<Event*>::const_iterator evIt = events.begin();
   for (;evIt!=events.end();evIt++) { // loop over all events
      const TMVA::Event* event = (*evIt);   // get the event

      UInt_t cls = (*evIt)->GetClass(); // get the class of this event

      FloatVector& minVector = fMin.at(cls); 
      FloatVector& maxVector = fMax.at(cls);

      FloatVector& minVectorAll = fMin.at(all);
      FloatVector& maxVectorAll = fMax.at(all);

      GetInput(event,input,mask);    // select the input variables for the transformation and get them from the event
      UInt_t iidx = 0;          
      for ( std::vector<Float_t>::iterator itInp = input.begin(), itInpEnd = input.end(); itInp != itInpEnd; ++itInp) { // loop over input variables
         Float_t val = (*itInp);

         if( minVector.at(iidx) > val ) minVector.at(iidx) = val;
         if( maxVector.at(iidx) < val ) maxVector.at(iidx) = val;

         if (nCls != 1) { // in case more than one class exists, compute min and max as well for all classes together
            if (minVectorAll.at(iidx) > val) minVectorAll.at(iidx) = val;
            if (maxVectorAll.at(iidx) < val) maxVectorAll.at(iidx) = val;
         }

         ++iidx;
      }
   }

   return;
}

//_______________________________________________________________________
std::vector<TString>* TMVA::VariableNormalizeTransform::GetTransformationStrings( Int_t cls ) const
{
   // creates string with variable transformations applied

   // if cls (the class chosen by the user) not existing, assume that user wants to 
   // have the matrix for all classes together. 
   if (cls < 0 || cls > GetNClasses()) cls = GetNClasses();

   Float_t min, max;
   const UInt_t size = fGet.size();
   std::vector<TString>* strVec = new std::vector<TString>(size);

   UInt_t iinp = 0;
   for( ItVarTypeIdxConst itGet = fGet.begin(), itGetEnd = fGet.end(); itGet != itGetEnd; ++itGet ) {
      min = fMin.at(cls).at(iinp);
      max = fMax.at(cls).at(iinp);

      Char_t type = (*itGet).first;
      UInt_t idx  = (*itGet).second;
      Float_t offset = min;
      Float_t scale  = 1.0/(max-min);      
      TString str("");
      VariableInfo& varInfo = (type=='v'?fDsi.GetVariableInfo(idx):(type=='t'?fDsi.GetTargetInfo(idx):fDsi.GetSpectatorInfo(idx)));

      if (offset < 0) str = Form( "2*%g*([%s] + %g) - 1", scale, varInfo.GetLabel().Data(), -offset );
      else            str = Form( "2*%g*([%s] - %g) - 1", scale, varInfo.GetLabel().Data(),  offset );
      (*strVec)[iinp] = str;

      ++iinp;
   }

   return strVec;
}

//_______________________________________________________________________
void TMVA::VariableNormalizeTransform::WriteTransformationToStream( std::ostream& o ) const
{
   // write the transformation to the stream
   o << "# min max for all variables for all classes one after the other and as a last entry for all classes together" << std::endl;

   Int_t numC = GetNClasses()+1;
   if (GetNClasses() <= 1 ) numC = 1;

   UInt_t nvars = GetNVariables();
   UInt_t ntgts = GetNTargets();

   for (Int_t icls = 0; icls < numC; icls++ ) {
      o << icls << std::endl;
      for (UInt_t ivar=0; ivar<nvars; ivar++)
         o << std::setprecision(12) << std::setw(20) << fMin.at(icls).at(ivar) << " " 
           << std::setprecision(12) << std::setw(20) << fMax.at(icls).at(ivar) << std::endl;
      for (UInt_t itgt=0; itgt<ntgts; itgt++)
         o << std::setprecision(12) << std::setw(20) << fMin.at(icls).at(nvars+itgt) << " " 
           << std::setprecision(12) << std::setw(20) << fMax.at(icls).at(nvars+itgt) << std::endl;
   }
   o << "##" << std::endl;
}

//_______________________________________________________________________
void TMVA::VariableNormalizeTransform::AttachXMLTo(void* parent) 
{
   // create XML description of Normalize transformation

   void* trfxml = gTools().AddChild(parent, "Transform");
   gTools().AddAttr(trfxml, "Name", "Normalize");
   VariableTransformBase::AttachXMLTo( trfxml );

   Int_t numC = (GetNClasses()<= 1)?1:GetNClasses()+1;

   for( Int_t icls=0; icls<numC; icls++ ) {
      void* clsxml = gTools().AddChild(trfxml, "Class");
      gTools().AddAttr(clsxml, "ClassIndex", icls);
      void* inpxml = gTools().AddChild(clsxml, "Ranges");
      UInt_t iinp = 0;
      for( ItVarTypeIdx itGet = fGet.begin(), itGetEnd = fGet.end(); itGet != itGetEnd; ++itGet ) {
         void* mmxml = gTools().AddChild(inpxml, "Range");
         gTools().AddAttr(mmxml, "Index", iinp);
         gTools().AddAttr(mmxml, "Min", fMin.at(icls).at(iinp) );
         gTools().AddAttr(mmxml, "Max", fMax.at(icls).at(iinp) );
         ++iinp;
      }
   }
}

//_______________________________________________________________________
void TMVA::VariableNormalizeTransform::ReadFromXML( void* trfnode ) 
{
   // Read the transformation matrices from the xml node
   Bool_t newFormat = kFALSE;

   void* inpnode = NULL;
   
   inpnode = gTools().GetChild(trfnode, "Selection"); // new xml format
   if( inpnode != NULL )
      newFormat = kTRUE;

   if( newFormat ){
      // ------------- new format --------------------
      // read input
      VariableTransformBase::ReadFromXML( inpnode );

      // read transformation information
      
      UInt_t size = fGet.size();
      UInt_t classindex, idx;

      void* ch = gTools().GetChild( trfnode, "Class" );
      while(ch) {
         Int_t ci = 0;
         gTools().ReadAttr(ch, "ClassIndex", ci);
         classindex = UInt_t(ci);

         fMin.resize(classindex+1);
         fMax.resize(classindex+1);
    
         fMin[classindex].resize(size,Float_t(0));
         fMax[classindex].resize(size,Float_t(0));

         void* clch = gTools().GetChild( ch );
         while(clch) {
            TString nodeName(gTools().GetName(clch));
            if(nodeName=="Ranges") {
               void* varch = gTools().GetChild( clch );
               while(varch) {
                  gTools().ReadAttr(varch, "Index", idx);
                  gTools().ReadAttr(varch, "Min",      fMin[classindex][idx]);
                  gTools().ReadAttr(varch, "Max",      fMax[classindex][idx]);
                  varch = gTools().GetNextChild( varch );
               }
            }
            clch = gTools().GetNextChild( clch );
         }
         ch = gTools().GetNextChild( ch );
      }
      SetCreated();
      return;
   }
   
   // ------------- old format --------------------
   UInt_t classindex, varindex, tgtindex, nvars, ntgts;
   // coverity[tainted_data_argument]
   gTools().ReadAttr(trfnode, "NVariables", nvars);
   // coverity[tainted_data_argument]
   gTools().ReadAttr(trfnode, "NTargets",   ntgts);
   // coverity[tainted_data_argument]

   for( UInt_t ivar = 0; ivar < nvars; ++ivar ){
      fGet.push_back(std::pair<Char_t,UInt_t>('v',ivar));
   }
   for( UInt_t itgt = 0; itgt < ntgts; ++itgt ){
      fGet.push_back(std::pair<Char_t,UInt_t>('t',itgt));
   }
   void* ch = gTools().GetChild( trfnode );
   while(ch) {
      gTools().ReadAttr(ch, "ClassIndex", classindex);

      fMin.resize(classindex+1);
      fMax.resize(classindex+1);
      fMin[classindex].resize(nvars+ntgts,Float_t(0));
      fMax[classindex].resize(nvars+ntgts,Float_t(0));

      void* clch = gTools().GetChild( ch );
      while(clch) {
         TString nodeName(gTools().GetName(clch));
         if(nodeName=="Variables") {
            void* varch = gTools().GetChild( clch );
            while(varch) {
               gTools().ReadAttr(varch, "VarIndex", varindex);
               gTools().ReadAttr(varch, "Min",      fMin[classindex][varindex]);
               gTools().ReadAttr(varch, "Max",      fMax[classindex][varindex]);
               varch = gTools().GetNextChild( varch );
            }
         } else if (nodeName=="Targets") {
            void* tgtch = gTools().GetChild( clch );
            while(tgtch) {
               gTools().ReadAttr(tgtch, "TargetIndex", tgtindex);
               gTools().ReadAttr(tgtch, "Min",      fMin[classindex][nvars+tgtindex]);
               gTools().ReadAttr(tgtch, "Max",      fMax[classindex][nvars+tgtindex]);
               tgtch = gTools().GetNextChild( tgtch );
            }
         }
         clch = gTools().GetNextChild( clch );
      }
      ch = gTools().GetNextChild( ch );
   }
   SetCreated();
}

//_______________________________________________________________________
void TMVA::VariableNormalizeTransform::BuildTransformationFromVarInfo( const std::vector<TMVA::VariableInfo>& var ) 
{
   // this method is only used when building a normalization transformation
   // from old text files
   // in this case regression didn't exist and there were no targets

   UInt_t nvars = GetNVariables();

   if(var.size() != nvars)
      Log() << kFATAL << "<BuildTransformationFromVarInfo> can't build transformation,"
            << " since the number of variables disagree" << Endl;

   UInt_t numC = (GetNClasses()<=1)?1:GetNClasses()+1;
   fMin.clear();fMin.resize( numC );
   fMax.clear();fMax.resize( numC );


   for(UInt_t cls=0; cls<numC; ++cls) {
      fMin[cls].resize(nvars+GetNTargets(),0);
      fMax[cls].resize(nvars+GetNTargets(),0);
      UInt_t vidx(0);
      for(std::vector<TMVA::VariableInfo>::const_iterator v = var.begin(); v!=var.end(); ++v, ++vidx) {
         fMin[cls][vidx] = v->GetMin();
         fMax[cls][vidx] = v->GetMax();
         fGet.push_back(std::pair<Char_t,UInt_t>('v',vidx));
      }
   }
   SetCreated();
}

//_______________________________________________________________________
void TMVA::VariableNormalizeTransform::ReadTransformationFromStream( std::istream& istr, const TString& )
{
   // Read the variable ranges from an input stream

   UInt_t nvars = GetNVariables();
   UInt_t ntgts = GetNTargets();
   for( UInt_t ivar = 0; ivar < nvars; ++ivar ){
      fGet.push_back(std::pair<Char_t,UInt_t>('v',ivar));
   }
   for( UInt_t itgt = 0; itgt < ntgts; ++itgt ){
      fGet.push_back(std::pair<Char_t,UInt_t>('t',itgt));
   }
   char buf[512];
   char buf2[512];
   istr.getline(buf,512);
   TString strvar, dummy;
   Int_t icls;
   TString test;
   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 >> icls;
      for (UInt_t ivar=0;ivar<nvars;ivar++) {
         istr.getline(buf2,512); // reading the next line
         std::stringstream sstr2(buf2);
         sstr2 >> fMin[icls][ivar] >> fMax[icls][ivar];
      }
      for (UInt_t itgt=0;itgt<ntgts;itgt++) {
         istr.getline(buf2,512); // reading the next line
         std::stringstream sstr2(buf2);
         sstr2 >> fMin[icls][nvars+itgt] >> fMax[icls][nvars+itgt];
      }
      istr.getline(buf,512); // reading the next line
   }
   SetCreated();
}

//_______________________________________________________________________
void TMVA::VariableNormalizeTransform::PrintTransformation( std::ostream& /* o */ ) 
{
   // prints the transformation ranges

   Int_t nCls = GetNClasses();
   Int_t numC = nCls+1;
   if (nCls <= 1 ) numC = 1;
   for (Int_t icls = 0; icls < numC; icls++ ) {
      if( icls == nCls )
         Log() << kINFO << "Transformation for all classes based on these ranges:" << Endl;
      else
         Log() << kINFO << "Transformation for class " << icls << " based on these ranges:" << Endl;
      UInt_t iinp = 0;
      for( ItVarTypeIdxConst itGet = fGet.begin(), itGetEnd = fGet.end(); itGet != itGetEnd; ++itGet ){
         Char_t type = (*itGet).first;
         UInt_t idx  = (*itGet).second;
         
         TString typeString = (type=='v'?"Variable: ": (type=='t'?"Target : ":"Spectator : ") );
         Log() << typeString.Data() << std::setw(20) << fMin[icls][idx] << std::setw(20) << fMax[icls][idx] << Endl;
         
         ++iinp;
      }
   }
}

//_______________________________________________________________________
void TMVA::VariableNormalizeTransform::MakeFunction( std::ostream& fout, const TString& fcncName, 
                                                     Int_t part, UInt_t trCounter, Int_t ) 
{
   // creates a normalizing function
   // TODO include target-transformation into makefunction
   UInt_t nVar = fGet.size();
   UInt_t numC = fMin.size();
   if (part==1) {
      fout << std::endl;
      fout << "   double fMin_"<<trCounter<<"["<<numC<<"]["<<nVar<<"];" << std::endl;
      fout << "   double fMax_"<<trCounter<<"["<<numC<<"]["<<nVar<<"];" << std::endl;
   }

   if (part==2) {
      fout << std::endl;
      fout << "//_______________________________________________________________________" << std::endl;
      fout << "inline void " << fcncName << "::InitTransform_"<<trCounter<<"()" << std::endl;
      fout << "{" << std::endl;
      fout << "   // Normalization transformation, initialisation" << std::endl;
      for (UInt_t ivar=0; ivar<nVar; ivar++) {
         for (UInt_t icls = 0; icls < numC; icls++) {
            Double_t min = TMath::Min( FLT_MAX, fMin.at(icls).at(ivar) );
            Double_t max = TMath::Max(-FLT_MAX, fMax.at(icls).at(ivar) );
            fout << "   fMin_"<<trCounter<<"["<<icls<<"]["<<ivar<<"] = " << std::setprecision(12)
                 << min << ";" << std::endl;
            fout << "   fMax_"<<trCounter<<"["<<icls<<"]["<<ivar<<"] = " << std::setprecision(12)
                 << max << ";" << 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 << "   // Normalization transformation" << std::endl;
      fout << "   if (cls < 0 || cls > "<<GetNClasses()<<") {"<< std::endl;
      fout << "   if ("<<GetNClasses()<<" > 1 ) cls = "<<GetNClasses()<<";"<< std::endl;
      fout << "      else cls = "<<(fMin.size()==1?0:2)<<";"<< std::endl;
      fout << "   }"<< std::endl;
      fout << "   const int nVar = " << nVar << ";" << std::endl << std::endl;
      fout << "   // get indices of used variables" << std::endl;
      VariableTransformBase::MakeFunction(fout, fcncName, 0, trCounter, 0 );
      fout << "   static std::vector<double> dv;" << std::endl; // simply made it static so it doesn't need to be re-booked every time
      fout << "   dv.resize(nVar);" << std::endl; 
      fout << "   for (int ivar=0; ivar<nVar; ivar++) dv[ivar] = iv[indicesGet.at(ivar)];" << std::endl;

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