/data3/calcul/jacquem/working_dir/Micromegas/micromegasFrameWork/src/analyse/root/merge.cpp

Go to the documentation of this file.

/* @version $Revision: 1654 $ * @modifiedby $Author: jacquem $ * @lastmodified $Date: 2012-04-13 16:20:27 +0200 (Fri, 13 Apr 2012) $ */
#include <map>
#include <stdlib.h>
#include <string>
#include <set>
#include <list>
#include "TKey.h"
#include <TRint.h>
#include <TKey.h>
#include <TTree.h>
#include <TFile.h>
#include <TChain.h>
#include <iostream>
#include <sstream>
#include "tools/Log.hh"
#include "tools/Toolbox.hh"

#include "root/MTRun.hh"
#include "root/MTChannel.hh"
#include "root/MTEvent.hh"



#include <string>

#include "MicroException.hh"

#include "mysql/Mysql.hh"



#define GLOBALTRIGGER 1
#define DIFSYNCHRO    2

using namespace std;

/*
    ON cherche les MTEvent venant d'un fichier root dont:
      -  les GlobalTriggerCounter  sont identiques pour les fusioner
      -  les DifSynchro  sont identiques pour les fusioner
   
    Root ne permet pas de recuperer des MTEvent d'un arbre et d'ajouter des nouveaux MTEvent dans un autre arbre simultanement
    a cause des misterieuses methodes ROOT ( Fill, setBranchAdress ...) + le fait que le TClonesArray soit une variable static 
    de la classe MTEvent

    On doit donc:
    1/ Stocker dans un dictionnaire ( map ) tout les evtNum de l'arbre origine qui ont le meme bcIdAbs dans leur premier MTChannel
    2/ Copier ( dans une nouvelle zone memoire pas gerer par root ) tous les MTChannel correspondant a ces MTEVent et on les stocke dans une liste
    3/ Pour chaque entree du dictionnaire ( correspondans a un bcidAbs ) on Cree un nuveau MTEvent, on lui affecte toutes les donnees d'un MTEvent venant de l'arbre root    sauf le MTChannel ( a cause de la variable de classe static ) 
    4/ On ajouter au nouvel evemenet tous les MTChannel precedemment stocke
      
*/  

//void merge( TTree& tree , TTree& mergedTree, TFile& newFile);
int merge(TString rootFileName);

bool FillEvent(const MTEvent& evt, MTEvent* mergedEvt)
{

        // On cree un eveneemnt dans mergedTree pour ce critere
              mergedEvt->SetTemperature(evt.GetTemperature());
        mergedEvt->SetPressure(evt.GetPressure());
        mergedEvt->SetDifSynchro(evt.GetDifSynchro());
        mergedEvt->SetTimestamp(evt.GetTimestamp());
        mergedEvt->SetGlobalTriggerCounter(evt.GetGlobalTriggerCounter());

        const std::map<UInt_t, std::map<UInt_t, std::map<UInt_t, Float_t>* >* >& meshs = evt.GetMeshVoltage();
        //for ( std::map<UInt_t, Float_t>::const_iterator iterMesh = meshs.begin(); iterMesh != meshs.end(); iterMesh++)
        for ( std::map<UInt_t, std::map<UInt_t, std::map<UInt_t, Float_t>* >* >::const_iterator iterChamber = meshs.begin(); iterChamber != meshs.end(); iterChamber++)
        {
            std::map<UInt_t, std::map<UInt_t, Float_t>* >&difContainer = *(iterChamber)->second;
            for ( std::map<UInt_t, std::map<UInt_t, Float_t>* >::const_iterator iterDif = difContainer.begin(); iterDif != difContainer.end(); iterDif++)
            {
              std::map<UInt_t, Float_t> &boardContainer = *(iterDif)->second;
              for ( std::map<UInt_t, Float_t>::const_iterator iterVoltage = boardContainer.begin(); iterVoltage != boardContainer.end(); iterVoltage++)
              {
                mergedEvt->SetMeshVoltage(iterChamber->first,iterDif->first,iterVoltage->first,iterVoltage->second);
              }
            }

        }

        const std::map<UInt_t, std::map<UInt_t, std::map<UInt_t, Float_t>* >* >& drifts = evt.GetDriftVoltage();
        //for ( std::map<UInt_t, Float_t>::const_iterator iterMesh = meshs.begin(); iterMesh != meshs.end(); iterMesh++)
        for ( std::map<UInt_t, std::map<UInt_t, std::map<UInt_t, Float_t>* >* >::const_iterator iterChamber = drifts.begin(); iterChamber != drifts.end(); iterChamber++)
        {
            std::map<UInt_t, std::map<UInt_t, Float_t>* >&difContainer = *(iterChamber)->second;
            for ( std::map<UInt_t, std::map<UInt_t, Float_t>* >::const_iterator iterDif = difContainer.begin(); iterDif != difContainer.end(); iterDif++)
            {
              std::map<UInt_t, Float_t> &boardContainer = *(iterDif)->second;
              for ( std::map<UInt_t, Float_t>::const_iterator iterVoltage = boardContainer.begin(); iterVoltage != boardContainer.end(); iterVoltage++)
              {
                mergedEvt->SetDriftVoltage(iterChamber->first,iterDif->first,iterVoltage->first,iterVoltage->second);
              }
            }

        }


}
//---------------------------------------------
//
//---------------------------------------------
bool FillChannels(const MTEvent& evt, list<MTChannel*>* hits)
{
        // on tourne sur tous les MTChannel
      for(int i=0;i<evt.GetNchannel() ;i++)
      {
          MTChannel *channel = (MTChannel*)evt.GetChannels()->At(i);
          // On instancie une nouvelle zone memoire pour s'affranchir de ROOT
          MTChannel* tmpCh = new MTChannel();

          // On copie le contenu du channel
          *tmpCh = *channel;
          // on ajoute les channel a la liste pour ce bcId_abs
          hits->push_back(tmpCh);
      }
   
     return true;
}
//---------------------------------------------
//
//---------------------------------------------
int main(int argc, char**argv){


  

   if ( argc < 3 || argc > 4   ) {
       FILE_LOG(logERROR)  << "usage:" << endl;
       FILE_LOG(logERROR)  << "-sort by globalTrigger:  merge  -g rootFile" << endl;
       FILE_LOG(logERROR)  << "-sort by difSynchro   :  merge  -d SlabsRootFile AHCALRootFile" << endl;
       exit(1);
   }


    // Get command arguments
    string  opt;
    opt.assign(argv[1]);
    if ( opt.compare("-g") != 0 && opt.compare("-d") != 0 )
    {
      FILE_LOG(logERROR)  << "usage: merge rootFile -g(globalTrigger) -d(difSynchro)  " << endl;
      exit(-1);
    }
    
    unsigned int criteria = GLOBALTRIGGER;
    string extension = "_MGT";
    
    if ( opt.compare("-d") == 0 ) { criteria = DIFSYNCHRO; extension = "_MDS";  }


    vector<string> fileNames;

    fileNames.push_back(argv[2]);

    if (  criteria == DIFSYNCHRO )
    {
      if (  argc <4 ) 
      {
        FILE_LOG(logERROR)  << "-sort by difSynchro   :  merge  -d SlabsRootFile AHCALRootFile" << endl;
        exit(0);
      }
      fileNames.push_back(argv[3]);
    }




    vector<UInt_t> misses;


    //Open Root File
    TTree* minEventTree = NULL;
    UInt_t minEventNum = 0xffffffff;
    UInt_t maxEventNum = 0x0;
    list<TTree*> trees;
    list<TFile*> files;

    for ( vector<string>::iterator iterFile = fileNames.begin(); iterFile != fileNames.end(); iterFile++)
    {
      string rootName = *iterFile;
      TFile *f = new TFile(rootName.c_str(),"READONLY");
      files.push_back(f);
      TIter nextkey(f->GetListOfKeys());
      TKey *key;
      // Loop over TTree, store name and min paramaters

       const MTEvent *evt =  new MTEvent();
       ui32 lastTotalGlobalTrigerCounter = 0; 



      while (key = (TKey*)nextkey())
      {
          try
          {
            TTree* tmp = dynamic_cast<TTree*>(key->ReadObj());
            trees.push_back(tmp);
            cout << "Add TTree["<< tmp->GetName() <<"] with [" << tmp->GetEntries() << "] entries." << endl;
            if ( tmp->GetEntries() <  minEventNum)
            {
                          minEventNum = tmp->GetEntries() ;
                    minEventTree = tmp;
                  }
            TBranch *branch= tmp->GetBranch("MTEvent");
            branch->SetAddress(&evt);


            tmp->GetEntry(tmp->GetEntries()-1);
            if ( lastTotalGlobalTrigerCounter == 0 ) 
            {
               lastTotalGlobalTrigerCounter = evt->GetGlobalTriggerCounter(); 
            }
            else 
            {
              if ( evt->GetGlobalTriggerCounter() != lastTotalGlobalTrigerCounter ) 
              {
                cout << "\n\n\n\n\n" << endl;
                FILE_LOG(logERROR) << " Last event of each TTree have not got the same GlobalTrigger counter value." << endl;
                FILE_LOG(logERROR) << " Synchronization failed. Data can not be merged" << endl;
                exit(-1);
              }
            }
          }
          catch (...) {}
      }
    }
    // Remove it to avoid auto looping
    if ( minEventTree != NULL )
    {
      cout << "Reference TTree[" << minEventTree->GetName() << "]" << endl;
      trees.remove(minEventTree);
    }

          string mergeFileName = fileNames[0].substr(0,fileNames[0].find("root")-1)+extension.c_str() + ".root";

          TFile *newFile = new TFile(mergeFileName.c_str(), "RECREATE");
          newFile->cd();
    // Creation du nouvel arbre destine a contenir les evenement merges
    TTree* mergedTree = new TTree("mergedTTree","MicroMegas merged event");
    // mergedTree->SetDirectory(0);
          cout << "Create new TFile for merge result[" <<mergeFileName  << "]"  << endl;

    // creation d' un nouvel evemenent merge
    MTEvent *mergedEvt = new MTEvent();
    if ( mergedTree->GetBranch("MTEvent") == 0)
    {
        mergedTree->Branch("MTEvent",mergedEvt);//,16000,2);// second argument is class of evt!!!
    }

    // on tourne sur tout les evenents de l arbre ayant le moins d' evenements
    TTree* refTree = minEventTree;
          MTRun * run  = (MTRun*)refTree->GetUserInfo()->FindObject("MTRun");
     TString svnVersion;
    if ( run != NULL ) { svnVersion = run->GetSvnVersion();}
    mergedTree->GetUserInfo()->Add(run); 
    int lastEventId = 0;
          ui32 nbchannelOrig = 0;
//        ui32 nbchannelOther = 0;
    map<string , UInt_t> lastEventIdMap;
    UInt_t nbChannels = 0;
    for ( int evtNum = 0; evtNum < refTree->GetEntries() ; evtNum++)
    {
        mergedEvt->SetCrcIsCorrect(true);
        const MTEvent *evt =  new MTEvent();
        TBranch *branch= refTree->GetBranch("MTEvent");
        branch->SetAddress(&evt);
        refTree->GetEntry(evtNum);

        FillEvent(*evt,mergedEvt);
                    mergedEvt->SetEventId(evtNum);
        if ( evt->GetCrcIsCorrect() == false )
        {
          mergedEvt->SetCrcIsCorrect(false);
        }

        UInt_t globalTrigger = evt->GetGlobalTriggerCounter() ;
        ULong64_t difSynchro = evt->GetDifSynchro();
        UInt_t difTrigger = evt->GetDifTriggerCounter() ;

        // create list for all Events channels with same criteria
        list<MTChannel*>* hits = new list<MTChannel*>();
        FillChannels(*evt,hits);
        //nbChannels  = nbChannels + hits->size();
              nbchannelOrig = nbchannelOrig+evt->GetNchannel();
        //   On cherche dans les autres arbres  les evenement avec ce meme criteria
        int evtNum2 = 0;
        for ( list<TTree*>::iterator iterTree = trees.begin(); iterTree != trees.end(); iterTree++)
        {
            TTree* tree = (TTree*)*iterTree;
            const MTEvent *evt =  new MTEvent();
            TBranch *branch= tree->GetBranch("MTEvent");
            branch->SetAddress(&evt);

                              bool find = false;
            string treeName =  string(tree->GetName());


            for ( evtNum2 = lastEventIdMap[treeName]; evtNum2< tree->GetEntries() ; evtNum2++)
            {
// FILE_LOG(logDEBUG) << " search in event [" << evtNum2 <<"]" << " \r" << flush;

                //max
                ////cout<<evtNum2<<" "<<evt->GetDifSynchro()<<endl;

                tree->GetEntry(evtNum2);
                if ( evt != NULL)
                {
                    if ( ( criteria == GLOBALTRIGGER && evt->GetGlobalTriggerCounter() == globalTrigger  )
                       ||( criteria == DIFSYNCHRO && evt->GetDifSynchro() == difSynchro  ))
                    {
                        find = true;
                        //---------------------------------
                        // on tourne sur tous les MTChannel
                        FillChannels(*evt,hits);
                        if ( evt->GetCrcIsCorrect() == false )
                        {
                          mergedEvt->SetCrcIsCorrect(false);
                        }

                                    //nbchannelOther = nbchannelOther + evt->GetNchannel();

                                                break;
                    }
                }
            } // end loop over current TTree events  (tree)
            if ( ! find )
            { 
              if ( criteria == GLOBALTRIGGER )
              {
//                 cout << "global trigger[" << tree->GetName() << " " << globalTrigger << "] not found" << endl;
                 misses.push_back(globalTrigger);
              }
              else if ( criteria == DIFSYNCHRO )
              {
                 cout << "difSynchro[" << tree->GetName() << " " << difSynchro << "] not found" << endl;
                 misses.push_back(difSynchro);
              }
                              }
            else
            {
              //cout << "---- difSynchro[" << tree->GetName() << " " << difSynchro << "] found" << endl;
              lastEventIdMap[treeName] = evtNum2;
            }

                  delete evt;
        } // end loop over TTree
        // Tous les MTChannel pour ce critere  ont ete recuperes.
        // On les ajoutes donc a notre nouveau MTEvent
        for ( list<MTChannel*>::iterator iterCh = hits->begin(); iterCh != hits->end(); iterCh++)
        {
            MTChannel* ch = *iterCh;
            mergedEvt->AddChannel(ch);
        }
        nbChannels  = nbChannels + hits->size();

        // On sauve les MTEvent dans le nouvel arbre
        // Lorsque l' on modifie le map nbHitPerBcidHit d' un evenement la methode MTEvent->Fill() devient beaucoup plus lent
        mergedTree->Fill();  // fill with mergedEvt
        if ( evtNum % 1 == 0)
              {
              FILE_LOG(logINFO  ) << "Done for entry " << evtNum  +1 << " / " << refTree->GetEntries() << "\r" << flush; 
        } 


        // Clean and free memory
        mergedEvt->SetNchannel(0); // Free memory
        for ( list<MTChannel*>::iterator iterCh = hits->begin(); iterCh != hits->end(); iterCh++)
        {

            delete (*iterCh) ; //delete MTChannel ch
        }
        delete hits;
        mergedEvt->Clear();


      delete evt;
    } //end loop over ref TTree events

        for ( list<TTree*>::iterator iterTree = trees.begin(); iterTree != trees.end(); iterTree++)
        {
            TTree* tree = (TTree*)*iterTree;
            MTRun * run  = (MTRun*)tree->GetUserInfo()->FindObject("MTRun");
            mergedTree->GetUserInfo()->Add(run);
        }



    mergedTree->Write("", TObject::kOverwrite);
                mergedTree->SetDirectory(0);
                newFile->Close();
    //f.Close();

    

    string comment = "No comment";
    bool behavior = true;
    if ( misses.size() > 0 )
    {
      behavior = false;
      string msg = "WARNING !!! Some event has not been merges. Find bellow list of criteria not found.";
      cout << msg << endl; 
      comment = msg;
      for ( vector<UInt_t>::const_iterator iter = misses.begin();  iter != misses.end() ; iter++)
      {
        cout << "["<< *iter << "]";
        ostringstream out;
        out << *iter;
        string sIndex = out.str();
        msg = msg + "[" +  sIndex  +  "]";
      }
      cout << endl;
    }
    cout <<  endl << "Done." << endl;

    //cout << "Last global trigger counter = " <<  globalTrigger << "]"  <<  endl; 

     Mysql mysql;
    // Add merge software in  DB if not already exist
    string svn(svnVersion.Data());
    FILE_LOG(logINFO) << " mysql.add merge Software to DB (" << svn << "]"  << endl;
    ui32 softId = mysql.addMergeSoftware(svn);

    // Add merge file
    size_t last_slash = mergeFileName.find_last_of("/")  +1 ;
    string name = mergeFileName.substr(last_slash);
    string path = mergeFileName.substr(0,last_slash);
    int mergeId = mysql.addMergeFile(softId,path,name,behavior,refTree->GetEntries(),nbChannels,true,comment);
    cout << "mergeId["  << mergeId << "]"  << endl;

    for ( vector<string>::iterator iterFile = fileNames.begin(); iterFile != fileNames.end(); iterFile++)
    {
      string full = *iterFile;
      size_t last_slash = full.find_last_of("/")  +1 ;
      string name = full.substr(last_slash);
      string path = full.substr(0,last_slash);
      try {
        ui32 rebuildId = mysql.getRebuildFile(path,name);
        mysql.connectMergeAndRebuildFile(rebuildId,mergeId);
      }
      catch ( MicroException e )
      {
        FILE_LOG(logWARNING) << "Rebuild file[" << path + name << "] not registerd in database." << endl;
      }

    }




    


    
}

---