class HHistMap: public TNamed

_HADES_CLASS_DESCRIPTION



 HHistMap
 helper class to hold a map of histogram, TCanvas, TCut,
 TF1 and TObject (parameters) pointers.
 The HHistMap is streamed into output file and can be
 read back to obtain all hists/canvas/cuts/fits/parmeters

#include "hhistmap.h"
#include "harray.h"
#include "htool.h"
#include "TH1.h"
#include "TH1F.h"
#include "TH2F.h"
#include "TROOT.h"
#include "TRandom.h"
#include "TMath.h"
#include "TObjArray.h"
#include "TF1.h"
#include "TMacro.h"

#include <iostream>
using namespace std;

Bool_t fillGaus(TH1* h ,TString name,HHistMap* map,TObjArray* params)
{
    // fill some random gauss with
    // randomized mean and sigma
    // h : hist                                    (set automatically)
    // array : h is part of this array in HHistMap (set automatically)
    // map : HHistMap owning this object           (set automatically)
    // params : user params

    // defaults
    Double_t meanlow  = 10;
    Double_t meanup   = 10;
    Double_t siglow   = 2 ;
    Double_t sigup    = 2 ;

    if(map){
        HArrayD* par = (HArrayD*) map->getPar("parsGaus");
	if(par){

	    TArrayD* pars = par->data;

	    meanlow = pars->At(0);
	    meanup  = pars->At(1);
	    siglow  = pars->At(2);
	    sigup   = pars->At(3);
	}
    }

    Double_t mean = meanlow + gRandom->Rndm() * (meanup-meanlow);
    Double_t sig  = siglow  + gRandom->Rndm() * (sigup -siglow );

    if (h)  for(Int_t i = 0 ; i < 1000; i ++ ) h->Fill(gRandom->Gaus(mean,sig));

    return kTRUE;
}

Bool_t fillRndm(TH1* h ,TString name,HHistMap* map,TObjArray* params)
{
    // fill some random
    // randomized range
    // h : hist                                    (set automatically)
    // array : h is part of this array in HHistMap (set automatically)
    // map : HHistMap owning this object           (set automatically)
    // params : user params

    // defaults
    Double_t meanlow  = 10;
    Double_t meanup   = 10;

    if(map){
	HArrayD* par = (HArrayD*) map->getPar("parsGaus");
	if(par){
	    TArrayD* pars = par->data;

	    meanlow = pars->At(0);
	    meanup  = pars->At(1);
	}
    }

    if (h)  for(Int_t i = 0 ; i < 10000; i ++ ) h->Fill(meanlow + gRandom->Rndm() * (meanup-meanlow));

    return kTRUE;
}

Bool_t fillMeanRms(TH1* h ,TString name,HHistMap* map,TObjArray* params)
{
    // fill mean and rms to some other histogram
    // h : hist                                    (set automatically)
    // array : h is part of this array in HHistMap (set automatically)
    // map : HHistMap owning this object           (set automatically)
    // params : user params

    // defaults

    if(map&&h){
	TH1* mean = map->get("h8_mean");
	TH1* rms  = map->get("h8_rms");

        Int_t index = map->getIndex(name,h);
	if(mean) {
	    mean->SetBinContent(index+1,h->GetMean());
	    mean->SetBinError  (index+1,h->GetMeanError());
	}
	if(rms){
	    rms ->SetBinContent(index+1,h->GetRMS());
            rms ->SetBinError  (index+1,h->GetRMSError());
        }
    }

    return kTRUE;
}

Bool_t setColor(TH1* h ,TString name,HHistMap* map,TObjArray* params)
{
    // set color of hists in array
    // h : hist                                   (set automatically)
    // name : h is part of this array in HHistMap (set automatically)
    // map : HHistMap owning this hist            (set automatically)
    // params : user params

    if(map){
        HArrayI* cols = (HArrayI*) map->getPar("colors");
	if(cols){
	    Int_t index   = map->getIndex(name,h);     // linear index of this object in array
	    h->SetLineColor(cols->data->At(index));
	}
    }
    return kTRUE;
}

void histmap()
{
    gROOT->SetBatch();

    HHistMap hM("test.root");  // all hist will go to test.root
    hM.setSilentFail(kTRUE);   // (default kFALSE), kTRUE: do not emmit errors when hists do not exist in get(), get2() etc.
    hM.addHist(new TH1F("h","h",100,0,100),"hists/h");  // single hist, stored in subdir hists/h in output


    //------------------------------------------------------------
    // create hist arrays outside HHistMap and add them to HHistMap
    TH1F* h1[6];
    for(Int_t sector=0;sector<6;sector++){
	h1[sector]=new TH1F(Form("h1_s%i",sector),Form("h1_s%i",sector),100,0,100);
    }

    // create a linear array for 2dim indexing
    TH1F* h2[24]; // 6x4 like h2[6][4]
    for(Int_t sector=0;sector<6;sector++){
	for(Int_t module=0;module<4;module++){
	    h2[HTool::getLinearIndex(sector,6,module,4)]= new TH1F(Form("h2_s%i_m%i",sector,module),Form("h2_s%i_m%i",sector,module),100,0,100);
	}
    }


    hM.addHistArray((TH1**)h1,"h1","h1_s%i"    ,"h1_s%i"    ,"hists/h1",6);    // 1dim array size 6
    hM.addHistArray((TH1**)h2,"h2","h2_s%i_m%i","h2_s%i_m%i","hists/h2",6,4);  // 2dim array size 6x4
    //------------------------------------------------------------




    //------------------------------------------------------------
    // create hist arrays inside HHistMap    ( see hM.addHistN(...) and  hM.addHistArrayN(...) for non const hists
    hM.addHist     ("TH1F","h3","h3",100,0,100,0,0,0,0,0,0,"time1 [ns]","counts","","hists/h3");

    TString secname= "I,II,III,IV,V,VI";
    TString modname= "I,II,III,IV";


    // create hist array with custom names
    hM.addHistArray("TH1F","h4","h4t1_s[%i]m[%i]","time1s[%i]m[%i]"
		    ,100,0.,100.
		    ,0,0.,0.
		    ,0,0.,0.
		    ,"time1 [ns]","counts","","hists/h4",6,4,-1,-1,-1,secname,modname);  // create hists with special names;

    hM.addHistArray("TH2F","h5","h5t1_t12_s[%i]m[%i]","time1_t12s[%i]m[%i]"
		    ,100,0.,100.
		    ,100,0.,100.
		    ,0,0.,0.
		    ,"time1 [ns]","t2-t1","","hists/h5",6,4);

    hM.addHistArray("TH1F","h6","h6t1_s[%i]m[%i]","time1s[%i]m[%i]"
		    ,100,0.,100.
		    ,0,0.,0.
		    ,0,0.,0.
		    ,"time1 [ns]","counts","","hists/h6",6,4);

    hM.addHistArray("TH1F","h7","h7t1_s[%i]m[%i]","time1s[%i]m[%i]"
		    ,100,0.,100.
		    ,0,0.,0.
		    ,0,0.,0.
		    ,"time1 [ns]","counts","","hists/h7",6,4);

    hM.addHist("TH1F","h8_mean","h8_mean",24,0,24,0,0,0,0,0,0,"time1 index [ns]","time1 mean [ns]","","hists/h8");
    hM.addHist("TH1F","h8_rms" ,"h8_rms" ,24,0,24,0,0,0,0,0,0,"time1 index [ns]","time1 rms [ns]" ,"","hists/h8");
    //------------------------------------------------------------


    //------------------------------------------------------------
    // get multi dimensional arrays created by HHistMap.
    // delete of the pointer arrays is done in destructor!
    TH2F*** h5 = NULL; h5 = hM.getDim2(h5,"h5");
    for(Int_t sector=0;sector<6;sector++){
	for(Int_t module=0;module<4;module++){
	    //cout<<sector<<" "<<module<<" "<<h5[sector][module]->GetName()<<endl;
	}
    }
    //------------------------------------------------------------


    //------------------------------------------------------------
    // create pointer arrays , not managed by HHistMap
    // take care about delete yourself
    TH2F*** htest = NULL;
    htest = HHistMap::newDim2(htest,6,4);
    // .... put hist pointer to array
    HHistMap::deleteDim2(htest,6,4,kFALSE); // delete only pointer array, not hists!
    //------------------------------------------------------------


    //########################################################################
    //########################################################################
    //########################################################################
    //########################################################################



    //------------------------------------------------------------
    // create canvas arrays outside HHistMap and add them to HHistMap
    hM.addCanvas(new TCanvas("c","c",500,500),1,0,500,500,"canvas/c");  // canvas outside created

    TCanvas* c1[6];
    for(Int_t sector=0;sector<6;sector++){
	c1[sector]=new TCanvas(Form("c1_s%i",sector),Form("c1_s%i",sector),500,500);
    }

   // create a linear array for 2dim indexing
    TCanvas* c2[24]; // 6x4 like c2[6][4]
    for(Int_t sector=0;sector<6;sector++){
	for(Int_t module=0;module<4;module++){
	    c2[HTool::getLinearIndex(sector,6,module,4)] = new TCanvas(Form("c2_s%i_m%i",sector,module),Form("c2_s%i_m%i",sector,module),500,500);
	}
    }


    hM.addCanvasArray((TCanvas**)c1,"c1","c1_s%i"    ,"c1_s%i"    ,1,0,500,500,"canvas/c1",6);    // 1dim array size 6
    hM.addCanvasArray((TCanvas**)c2,"c2","c2_s%i_m%i","c2_s%i_m%i",1,0,500,500,"canvas/c2",6,4);  // 2dim array size 6x4
    //------------------------------------------------------------




    //------------------------------------------------------------
    // create canvas arrays inside HHistMap
    hM.addCanvas     ("c3","c3",2,1,500,500,"canvas/c3");
    hM.addCanvasArray("c4","c4t1_s[%i]m[%i]","c4time1s[%i]m[%i]"
		      ,1,0,500,500
                      ,"canvas/c4"
		      ,6,4);
    //------------------------------------------------------------


    //------------------------------------------------------------
    // get multi dimensional arrays created by HHistMap.
    // delete of the pointer arrays is done in destructor!
    TCanvas*** c4 = NULL; c4 = hM.getCanvasDim2(c4,"c4");
    for(Int_t sector=0;sector<6;sector++){
	for(Int_t module=0;module<4;module++){
	    //cout<<sector<<" "<<module<<" "<<c4[sector][module]->GetName()<<endl;
	}
    }
    //------------------------------------------------------------


    //------------------------------------------------------------
    // create pointer arrays , not managed by HHistMap
    // take care about delete yourself
    TCanvas*** ctest = NULL;
    ctest = HHistMap::newDim2(ctest,6,4);
    // .... put hist pointer to array
    HHistMap::deleteDim2(ctest,6,4,kFALSE); // delete only pointer array, not hists!
    //------------------------------------------------------------


    //########################################################################
    //########################################################################
    //########################################################################
    //########################################################################
    // accessing objects


    //------------------------------------------------------------
    // METHOD I:
    // access the histograms by name : use the lable
    // retrieve pointer by :
    // TH1* get()
    // TH2* get2()  for 2Dim hists  (get will work too, but some funtcion of TH2 can not be used with TH1 pointer)
    // TH3* get3()  for 3dim hists  (get will work too, but some funtcion of TH3 can not be used with TH1 pointer)

    hM.get("h")     ->FillRandom("gaus",1000);  // single
    hM.get("h1",1)  ->FillRandom("gaus",1000);  // 1dim index 1
    hM.get("h2",1,0)->FillRandom("gaus",1000);  // 2dim index [1][0]
    for(Int_t i=0;i<1000;i++) hM.get ("h5",1,0)->Fill(gRandom->Gaus()*10+50,gRandom->Gaus()*10+50);     // function in TH1
    for(Int_t i=0;i<1000;i++) hM.get2("h5",1,1)->Fill(gRandom->Gaus()*10+50,gRandom->Gaus()*10+50,2.);  // function in TH2

    //------------------------------------------------------------

    //------------------------------------------------------------
    // METHOD II:
    // access the histograms by name : use the lable
    // retrieve a dynamically created multidim pointer

    TH2F*** h5_access = NULL;
    h5_access = hM.getDim2(h5,"h5");
    h5_access[0][0]->Fill( 1000, 100);
    //------------------------------------------------------------

    //------------------------------------------------------------
    // METHOD I:
    // access the canvas by name : use the lable
    hM.getCanvas("c3")     ->cd(1); // single canvas 2pads
    hM.get("h5",1,0)->Draw("colz");
    hM.getCanvas("c3")     ->cd(2); // single
    hM.get("h5",1,1)->Draw("colz");

    hM.getCanvas("c1",1)  ->cd(); // 1dim index 1
    hM.getCanvas("c2",1,0)->cd(); // 2dim index [1][0]
    //------------------------------------------------------------

    //------------------------------------------------------------
    // METHOD II:
    // access the histograms by name : use the lable
    TCanvas*** c4_access = NULL;
    c4_access = hM.getCanvasDim2(c4_access,"c4");
    c4_access[0][0]->cd();
    //------------------------------------------------------------


    //------------------------------------------------------------
    // working with cuts and params

    Double_t xcut[]= {
	0.191092,
	0.144397,
	0.15158,
	0.318606,
	0.483836,
	0.548491,
	0.51796,
	0.37967,
	0.221624,
	0.201868,
	0.191092};

    Double_t  ycut[]={
	83.8983,
	67.4788,
	47.3517,
	32.5212,
	34.375,
	55.8263,
	77.8072,
	89.4597,
      87.6059,
	85.7521,
	83.8983};

    hM.addCut("myCut",sizeof(xcut)/sizeof(Double_t),xcut,ycut,"cut");

    Double_t vals[4] = {30,50,2,6};
    HArrayD parsGaus(sizeof(vals)/sizeof(Double_t),vals); // wrapper for TArray
    parsGaus.print();

    hM.addPar(&parsGaus,"parsGaus","pars");

    Int_t colorsMod[4] = {1,2,4,8};
    HArrayI colors(24);
    Int_t* cl = colors.getArray();
    for(Int_t s = 0; s < 6; s ++) {
       for(Int_t m = 0; m < 4; m ++) {
	    cl[HTool::getLinearIndex(s,6,m,4)] = colorsMod[m];
	}
    }
    hM.addPar(&colors,"colors","pars");
    colors.print();

    //------------------------------------------------------------

    //------------------------------------------------------------
    // working with functions on arrays

    hM.functionArray("h4", fillGaus   ,NULL); // fill some random  distributions
    hM.functionArray("h4", fillMeanRms,NULL); // fill hist with means+rms of h4   "h8_mean" "h8_rms"
    hM.functionArray("h6", fillRndm   ,NULL); // fill some random  distributions
    hM.functionArray("h4", setColor   ,NULL); // setColors per module
    hM.functionArray("h6", setColor   ,NULL); // setColors per module


    //see also : 2 and 3 operator add,multiply,divide
    hM.addArray     ("h7","h6",1.,1.);  // make copy of h6 to h7
    hM.divideArray  ("h6","h4",1.,1., "");
    //hM.multiplyArray("h6","h4",1.,1., "");
    // standard actions
    //hM.resetArray ("h7","");
    //hM.scaleArray ("h7", 2.);
    //hM.sumW2Array ("h7");
    //------------------------------------------------------------

    //------------------------------------------------------------
    // working with macros

	TF1* fgaus = new TF1("fgaus","gaus",-1,1);
	fgaus->SetLineColor(2);
	hM.addFit(fgaus,"fits/gaus");

      hM.addCanvas("c10","c10",1,1,500,500,"canvas/c2");


	TMacro* mac = new TMacro("drawHist");
	//mac->ReadFile("./histmac/hhistmap_drawHist.C");  // read  macro from existing file (file should not be in workdir)

	mac->AddLine("void drawHist(){");
	mac->AddLine("cout<<\"exec drawHist\"<<endl;");
	mac->AddLine("gHHistMap->getCanvas(\"c10\")->Draw();");
	mac->AddLine("gHHistMap->getCanvas(\"c10\")->cd();");
	mac->AddLine("gHHistMap->get(\"h\")->SetLineColor(4);");
	mac->AddLine("gHHistMap->get(\"h\")->SetLineStyle(2);");
	mac->AddLine("gHHistMap->get(\"h\")->SetMarkerStyle(8);");
	mac->AddLine("gHHistMap->get(\"h\")->SetMarkerColor(8);");
	mac->AddLine("gHHistMap->getFit(\"fgaus\")->SetRange(-1,1);");
	mac->AddLine("gHHistMap->get(\"h\")->Fit(gHHistMap->getFit(\"fgaus\"),\"R\");");
	mac->AddLine("cout<<\"mean =\"<<gHHistMap->getFit(\"fgaus\")->GetParameter(1)<<\" sig =\"<<gHHistMap->getFit(\"fgaus\")->GetParameter(2)<<endl;");
	mac->AddLine("gHHistMap->get(\"h\")->Draw(\"PL\");");
	mac->AddLine("gHHistMap->getCanvas(\"c10\")->Update();");
	mac->AddLine("}");
      // mac->SaveSource("./histmac/hhistmap_drawHist.C"); // write macro to text file

	hM.addMacro(mac,"drawHist","macros/draw");

      hm->getMacro("drawHist")->Print();  // print source code
      hm->getMacro("drawHist")->Exec();   // execute the macro

    //------------------------------------------------------------

    // print content of HHistMap
    hM.print();
    //hM.printMap();
    //hM.printCanvasMap();
    //hM.printCutMap();
    //hM.printParameterMap();
    //hM.printMacroMap();


    //------------------------------------------------------------
    // input + output
    hM.writeHists();                       // write hists + canvas + cuts + fits + params + HHistMap  to root file
    //------------------------------------------------------------


    //------------------------------------------------------------
    // merging of root files
    HHistMap::addHistMap("histmap_file_*.root","merge.root"); // merge all HHistMap objects in matching files into merge.root
    HHistMap::addHistMap("histmap_file_1.root,histmap_file_2.root,histmap_file_3.root","merge.root"); // merge all HHistMap objects in files 1,2,3 into merge.root
    HHistMap::addHistMap("histmap_file_list.txt,histmap_file_2.root,histmap_file_3.root","merge.root"); // merge all HHistMap objects in files of filelist into merge.root
    //------------------------------------------------------------