ADTree.C

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2010 by Olivier Stezowski                               *
 *   stezow(AT)ipnl.in2p3.fr                                               *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include "ADTree.h"
#include "TSystem.h"
#include "TH1.h"

#include "MetaWatchers.h"
#include "AgataGeometryTransformer.h"

//--------------------------------------------------------------------------/
//ClassImp(ADKeyTree);

ADKeyTree::ADKeyTree(const char *name, const char *title, TTree *tree) :
    Watcher(name,title),
    TTreeBuilder(name,title,tree)
{
    if ( GetTree() ) { // just add the branch for that watcher
        SetBranches();
    }
}

Bool_t ADKeyTree::SetTrigger( ADF::DFTrigger *trigger )
{
    // Action once a the Frame is passed to this
    fFrame = trigger->GetInputSharedFP();

    // unset the frame to be treated
    if ( fFrame == 0x0 )
        return false;

    // trigger and Frame set,
    fKey = dynamic_cast<const AgataKey *>(fFrame->GetFrame()->GetKey());
    if ( fKey == 0x0 ) {
        return false;
    }
    else{
        return true;
    }
}

void ADKeyTree::SetBranches()
{
    GetTree()->Branch("EventNumber", &fEventNumber, "evnumber/i");
    GetTree()->Branch("TimeStamp", &fTimestamp,   "timestamp/l");
}

void ADKeyTree::Exec(Option_t * /*option*/)
{
    // for debugging purpose
    if ( gDebug > 3 )
        printf("ADKeyTree::Exec is called \n");

    // be sure the frame has been set properly
    if ( fFrame == 0x0 || !fFrame->IsValid() )
    { SetLastExecStatus(1); return; }

    // get event # and timestamp from the key and fill the tree
    fEventNumber = fKey->GetEventNumber();
    fTimestamp   = fKey->GetTimeStamp();

    // fill the tree only if this is the owner of the tree ... otherwise by TreeMaster
    FillTree();
}

//--------------------------------------------------------------------------/
//ClassImp(ADTrackTree);

ADTrackTree::ADTrackTree(const char *name, const char *title, TTree *tree) :
    TrackedWatcher(name,title),
    TTreeBuilder(name,title,tree),
    fVertexBuilder(0x0)
{
    // Vertex used for doppler correction, last registered
    fVertexBuilder = VertexBuilder::theCurrentVertexBuilder();

    if ( GetTree() ) { // just add the branch for that watcher
        SetBranches();
    }
}

void ADTrackTree::SetBranches()
{
    GetTree()->Branch("nbTrack",&nbTrack,"nbTrack/I");
    GetTree()->Branch("trackE", trackE, "trackE[nbTrack]/F");
    GetTree()->Branch("trackEDC", trackEDC, "trackEDC[nbTrack]/F");
    GetTree()->Branch("trackX1",trackX1,"trackX1[nbTrack]/F");
    GetTree()->Branch("trackY1",trackY1,"trackY1[nbTrack]/F");
    GetTree()->Branch("trackZ1",trackZ1,"trackZ1[nbTrack]/F");
    GetTree()->Branch("trackX2",trackX2,"trackX2[nbTrack]/F");
    GetTree()->Branch("trackY2",trackY2,"trackY2[nbTrack]/F");
    GetTree()->Branch("trackZ2",trackZ2,"trackZ2[nbTrack]/F");
    GetTree()->Branch("trackXS",trackXS,"trackXS[nbTrack]/F");
    GetTree()->Branch("trackYS",trackYS,"trackYS[nbTrack]/F");
    GetTree()->Branch("trackZS",trackZS,"trackZS[nbTrack]/F");
    GetTree()->Branch("cosTheta",cosTheta,"cosTheta[nbTrack]/F");
    GetTree()->Branch("trackT", trackT, "trackT[nbTrack]/F");
    GetTree()->Branch("trackCrystalID",trackCrystalID,"trackCrystalID[nbTrack]/I");
    
    GetTree()->Branch("TStrack",     &fTimestamp,    "TStrack/l");

#ifdef CHECK_COMMISSIONING_GANIL
    GetTree()->Branch("Eg",Eg,"Eg[45]/F");
    GetTree()->Branch("Eg1",Eg1,"Eg1[45]/F");
    GetTree()->Branch("EgA",EgA,"EgA[45]/F");
#endif
}

ADTrackTree::~ADTrackTree()
{
}

#include "TVector3.h"

void ADTrackTree::Exec(Option_t * /*option*/)
{
    // be sure the frame has been set properly
    if ( fFrame == 0x0 || !fFrame->IsValid() ) {
        SetLastExecStatus(1);
        return;
    }

    fTimestamp = ((AgataKey *)fFrame->GetFrame()->GetKey())->GetTimeStamp();
    
    // to get the data part of the frame
    const GammaTrackedInterface *data = GetCstDataPointer<GammaTrackedInterface>(fFrame);
    VertexInterface *vertex = fVertexBuilder->GetVertex();

    // Check Costheta
    Double_t px, py, pz, dx, dy, dz;
    vertex->GetPosition (px, py, pz); vertex->GetDirection(dx, dy, dz);
    
#ifdef CHECK_COMMISSIONING_GANIL
    for (UShort_t i = 0u; i < MaxG; i++)
        Eg[i] = Eg1[i] = EgA[i] = 0.;
#endif
    
    // now fill the tree
    nbTrack = data->GetNbGamma();
    for (UShort_t i = 0u; i < nbTrack; i++) {
        
        const TrackedHit *gamma1 = data->GetGamma(i);
        const Hit *hit1 = gamma1->GetHit();
        
        Double_t x = gamma1->GetX() - px;
        Double_t y = gamma1->GetY() - py;
        Double_t z = gamma1->GetZ() + fZOffset - pz;
        
        //      cout << gamma1->GetID() << " "  << gamma1->GetT() << " "  << gamma1->GetE()<< " " <<  << endl;
        //   cout <<  gamma1->GetE() << " " << hit1->GetT() << " " << hit1->GetID(1) << " " << endl;
        
        Double_t dd = x*x + y*y + z*z;
        if( !(dd == 0.0) ) {
            cosTheta[i] = (x*dx + y*dy + z*dz)/::sqrt(dd);
        }
        else
        {
            cosTheta[i] = 0.;
        }
        
        trackE[i]          = gamma1->GetE();
        trackCrystalID[i]  = gamma1->GetID();
        trackEDC[i]        = DoDopplerCorrection(gamma1, vertex);
        
        //      cout << " IN TrackTree " << i << " " << trackE[i] << " " << trackEDC[i]   << endl;
        
        trackXS[i] = x;
        trackYS[i] = y;
        trackZS[i] = z;
        trackT[i] = hit1->GetT();
        trackCrystalID[i] = hit1->GetID(1);
        
#ifdef CHECK_COMMISSIONING_GANIL
        TVector3 Vecg;
        if(i<MaxG)
        {
            Eg1[i] = trackE[i];
            //New Formula Zgoubi coordinates considered
            
            Double_t Beta = vertex->GetBeta();
            Double_t Gamma =  vertex->GetGamma();
            Double_t XV = dy;
            Double_t YV = -1.*dx;
            Double_t ZV = dz;
            Vecg.SetXYZ(trackYS[i],-1.*trackXS[i],trackZS[i]);
            
            Double_t Theta = Vecg.Theta();
            Double_t Phi = Vecg.Phi();
            
            Float_t CosAlpha =
                sin(Theta)*
                cos(Phi)*
                XV +
                YV*
                sin(Theta) *
                sin(Phi) +
                ZV*cos(Theta);
            
            Eg[i] = Eg1[i] * (Gamma)*(1.0 - (Beta)*CosAlpha);
            EgA[i] = acos(CosAlpha) * TMath::RadToDeg();
        }
#endif
        trackX1[i] = gamma1->GetX();
        trackY1[i] = gamma1->GetY();
        trackZ1[i] = gamma1->GetZ();
        
        
        if ( gamma1->GetHit(1) ) {
            trackX2[i] = gamma1->GetHit(1)->GetX();
            trackY2[i] = gamma1->GetHit(1)->GetY();
            trackZ2[i] = gamma1->GetHit(1)->GetZ();
        }
        else {
            trackX2[i] = gamma1->GetX();
            trackY2[i] = gamma1->GetY();
            trackZ2[i] = gamma1->GetZ();
        }
    }
    
    
    /*

    // now fill the tree
    nbTrack = data->GetNbGamma();
    for (UShort_t i = 0u; i < nbTrack; i++) {

        const TrackedHit *gamma1 = data->GetGamma(i);

        trackE[i]    = gamma1->GetE();
        trackEDC[i]  = DoDopplerCorrection(gamma1, vertex);

        trackX1[i] = gamma1->GetX();
        trackY1[i] = gamma1->GetY();
        trackZ1[i] = gamma1->GetZ();

        if ( gamma1->GetHit(1) ) {
            trackX2[i] = gamma1->GetHit(1)->GetX();
            trackY2[i] = gamma1->GetHit(1)->GetY();
            trackZ2[i] = gamma1->GetHit(1)->GetZ();
        }
        else {
            trackX2[i] = gamma1->GetX();
            trackY2[i] = gamma1->GetY();
            trackZ2[i] = gamma1->GetZ();
        }
    }
     */
    FillTree();
}

//--------------------------------------------------------------------------/
//ClassImp(ADHitTree);

ADHitTree::ADHitTree(const char *name, const char *title, TTree *tree) :
    EventPSAWatcher(name,title),
    TTreeBuilder(name,title,tree),
    fVertexBuilder(0x0),
    fTrans(0x0)
{
    fVertexBuilder = VertexBuilder::theCurrentVertexBuilder();
    if ( fVertexBuilder == 0x0 )
        std::cout << "Should not be NULL " << std::endl;
    
    fTrans = new AgataGeometryTransformer();
    if ( gSystem->AccessPathName("CrystalPositionLookUpTable") ) { // does not exist
        if ( gSystem->AccessPathName("CrystalPositionLookUpTable.dat") ) {
            fLog << error << " CrystalPositionLookUpTable required " << nline;
        }
        else {
            fLog << info << " Ge positions extracted from CrystalPositionLookUpTable.dat " << nline;
            fTrans->ReadTransformations("CrystalPositionLookUpTable.dat");
        }
    }
    else {
        fLog << info << " Ge positions extracted from CrystalPositionLookUpTable.dat " << nline;
        fTrans->ReadTransformations("CrystalPositionLookUpTable");
    }
    
    if ( GetTree() ) { // just add the branch for that watcher
        SetBranches();
    }
    
    // create spetra
    fIdSpectra = MakeTH1<TH1F>("hit_ID_spectra","Spectra of the ID ",100,0,100);
    fSumSpectra = MakeTH1<TH1F>("SumSpectra","Sum of all core energy ",4096,0,4096);
    fhitAgata  = MakeTH3<TH3F>("hitDW","Tracking from TaDSSD to WallD ;x;y;z",100,-200.,200.,100,-200.,200.,200,-4000.,4000.);
    
    
}

ADHitTree::~ADHitTree()
{
}

void ADHitTree::SetBranches()
{
    GetTree()->Branch("nbHits",&nbHits,"nbHits/I");
    GetTree()->Branch("ESum",&ESum,"ESum/F");
    GetTree()->Branch("hitE",hitE,"hitE[nbHits]/F");
    GetTree()->Branch("hitX",hitX,"hitX[nbHits]/F");
    GetTree()->Branch("hitY",hitY,"hitY[nbHits]/F");
    GetTree()->Branch("hitZ",hitZ,"hitZ[nbHits]/F");
    GetTree()->Branch("hitGX",hitGX,"hitGX[nbHits]/F");
    GetTree()->Branch("hitGY",hitGY,"hitGY[nbHits]/F");
    GetTree()->Branch("hitGZ",hitGZ,"hitGZ[nbHits]/F");
    GetTree()->Branch("hitId",hitId,"hitId[nbHits]/I");
    GetTree()->Branch("hitSg",hitSg,"hitSg[nbHits]/I");

    GetTree()->Branch("nbCores",&nbCores,"nbCores/I");
    GetTree()->Branch("coreId",coreId,"coreId[nbCores]/I");
    GetTree()->Branch("coreE0",coreE0,"coreE0[nbCores]/F");
    GetTree()->Branch("coreE1",coreE1,"coreE1[nbCores]/F");
    GetTree()->Branch("coreT0",coreT0,"coreT0[nbCores]/F");
    GetTree()->Branch("coreT1",coreT1,"coreT1[nbCores]/F");
    GetTree()->Branch("coreDE0",coreDE0,"coreDE0[nbCores]/F");
    GetTree()->Branch("coreDE1",coreDE1,"coreDE1[nbCores]/F");
    GetTree()->Branch("velDop",velDop,"velDop[nbCores]/F");
    GetTree()->Branch("hit_per_cryst",hit_per_cryst,"hit_per_cryst[nbCores]/I");

    GetTree()->Branch("TSHit",     &fTimestamp,    "TSHit/l");
}

void ADHitTree::Exec(Option_t * /*option*/)
{
    //  cout << "Exec MyhitTree " << endl;
    // be sure the frame has been set properly
    if ( fFrame == 0x0 || !fFrame->IsValid() ) {
        SetLastExecStatus(1u);
        return;
    }
    if ( !fFrame->IsValid() ){  //For empty event:data:psa purpose
        nbHits =0;
        nbCores =0;
        for(int i=0; i<MaxCore ; i++) {//empty array coreE0 coreE1
            coreE0[i]=-1;
            coreE1[i]=-1;
            coreT0[i]=-1;
            coreT1[i]=-1;
            velDop[i]=-1;
            coreDE0[i]=-1;
            coreDE1[i]=-1;
        }
        return;
    }
    
    fTimestamp = ((AgataKey *)fFrame->GetFrame()->GetKey())->GetTimeStamp();
    
    Double_t max_e0 = 0.0; Double_t xLocal, yLocal, zLocal, xGlobal, yGlobal, zGlobal, xt,yt,zt; TrackedHitImp<EHit,EHit> gamma; Int_t nb_hits = 0;
    
    // the vertex used for doppler correction
    VertexInterface *vertex = fVertexBuilder->GetVertex();

    // Get beta0 for doppler correction
    Float_t beta0 =-1;
    // Nb_of hits per crystals
    
    if ( vertex ) {
        beta0=vertex->GetBeta();
    }
    
    //Initialisation:
    //--Init total number of hit per event
    nbHits = nbCores = 0;

    for(UInt_t i = 0u; i < GetNbFramePSA(); ++i)
    {
        //
        PSAInterface *data = GetDataPSA(i);

        //Fill spectra
        fIdSpectra->Fill(data->GetUID());
        fSumSpectra->Fill(data->GetE());
        
        nb_hits = data->GetNbHits();
        // Core like branches
        coreId[nbCores] = data->GetUID();
        coreE0[nbCores] = data->GetE();
        coreE1[nbCores] = data->GetE(1u);
        coreT0[nbCores] = data->GetT();
        coreT1[nbCores] = data->GetT(1u);
        hit_per_cryst[nbCores] = nb_hits;
        velDop[nbCores] = beta0;

        // Loop on the hit to get over the hits with the max of the energy
        max_e0 = 0.0;
        for (Int_t j = 0; j < nb_hits; ++j) {
            
            const PSAHit* pHit = (PSAHit*)data->GetHit(j);
            
            hitE[nbHits]   = pHit->GetE();
            ESum          += hitE[nbHits];
            hitX[nbHits]   = pHit->GetX();
            hitY[nbHits]   = pHit->GetY();
            hitZ[nbHits]   = pHit->GetZ();
            hitId[nbHits]  = data->GetUID() ;
            hitSg[nbHits]  = pHit->GetID();
            
            //Get hit position
            pHit->GetXYZ(xLocal, yLocal, zLocal);
            //To the AGATA global ref
            fTrans->Local2Global(data->GetUID(), xLocal, yLocal, zLocal, xGlobal, yGlobal, zGlobal);
            
            // Set the Position of the hit in global ref of PRESPEC
            hitGX[nbHits]= xGlobal; // inversion X-Y and opposite direction
            hitGY[nbHits]= yGlobal; // inversion Y-X and opposite direction
            hitGZ[nbHits]= zGlobal; // z
            fhitAgata->Fill(xGlobal,yGlobal, zGlobal);
            
            // Now look for the hit with the highest energy, taken for Doppler correction
            // Kind of tracking in crystal
            //
            //Get hit position
            pHit->GetXYZ(xLocal, yLocal, zLocal);
            //To the AGATA global ref
            fTrans->Local2Global(data->GetUID(), xLocal, yLocal, zLocal, xGlobal, yGlobal, zGlobal);
            
            if ( vertex &&beta0>0 && beta0<1) { // Get the position of the source
                vertex->GetPosition(xt,yt,zt);
                fhitAgata->Fill(xt,yt,zt);
            }
            
            if ( pHit->GetE() > max_e0 ) { // gamma contains the position of the interaction with the highest energy in 3D
                // Situation @ GSI
                // gamma.SetXYZ(-yGlobal, -xGlobal, zGlobal); //x,y,z->-y,-x,-z
                // Situation @ GANIL ... TO BE Checked
                gamma.SetXYZ(xGlobal, yGlobal, zGlobal);
                max_e0 = pHit->GetE();
            }

            nbHits++;
        }
        
        Double_t edc0 = -1, edc1 = -1;
        if ( vertex ) {
            gamma.SetE(coreE0[nbCores]);
            edc0 = DoDopplerCorrection(&gamma,vertex);
            gamma.SetE(coreE1[nbCores]);
            edc1 = DoDopplerCorrection(&gamma,vertex);
        }
        coreDE0[nbCores] = edc0; //if there is no vertex, no energy
        coreDE1[nbCores] = edc1; //if there is no vertex, no energy
        
        if ( nbHits == 500 ) {
            SetLastExecStatus(1u);
            fLog << error << " Number of Hits to hit in ! " << nbHits << nline;
            nbHits = nbCores = 0;
            break;
        }
        nbCores++;

    } // end loop over PSA frame
    
    FillTree();
}

Double_t ADHitTree::DoDopplerCorrection(const TrackedHit *hit, VertexInterface *vertex)
{
    Double_t e = hit->GetE(), beta = vertex->GetBeta(), gamma = vertex->GetGamma();

    Double_t px, py, pz, dx, dy, dz;
    vertex->GetPosition (px, py, pz);
    vertex->GetDirection(dx, dy, dz);
    
    //    std::cout << " " << px << " " << py << " " << pz <<std::endl;
    //    std::cout << " " << dx << " " << dy << " " << dz <<std::endl;
    
    Double_t x = hit->GetX() - px;
    Double_t y = hit->GetY() - py;
    Double_t z = hit->GetZ() - pz;

    Double_t dd = x*x + y*y + z*z;
    if( !(dd == 0.0) ) {
        Double_t cosTheta = (x*dx + y*dy + z*dz)/::sqrt(dd);
        e = VertexInterface::DopplerCorrection(e,beta,gamma,cosTheta);
    }
    else e = -1.0;

    return e;
}

void ADHitTree::FillSpectraByUser()
{
    //Nothing yet.
}

//ClassImp(ADCoincTree);

ADCoincTree::ADCoincTree(const char *name, const char *title, TTree *tree)
: EventWatcher(name,title), TTreeBuilder(name,title,tree)
{
    if ( GetTree() ) { // just add the branch for that watcher
        SetBranches();
    }
}

ADCoincTree::~ADCoincTree()
{
}

void ADCoincTree::SetBranches()
{
    // cout << " SetBranches\t"<< fTSCoinc << endl;
    GetTree()->Branch("TSDiff", &fTSCoinc, "TSDiff/F");
}

void ADCoincTree::Exec(Option_t * /*option*/)
{
    // to get the main key
    AgataKey * mainkey = dynamic_cast<AgataKey *> (GetTrigger()->GetInputFrame(0u)->GetKey()), *subkey = 0x0;

    fTSCoinc = 0;
    
    // loop on subframes and compute the timestamp differences
    for(UInt_t which = 1u; which < GetTrigger()->GetNbInputFrame(); which++){

        SharedFP *fp = GetTrigger()->GetInputSharedFP(which);
        if ( fp == 0x0 || !fp->IsValid() )
            continue;
        
        // the subkey
        subkey = dynamic_cast<AgataKey *> (GetTrigger()->GetInputFrame(which)->GetKey());
        break;
    }
    if ( subkey ) {
        fTSCoinc = subkey->GetTimeStamp() - mainkey->GetTimeStamp();
    }
    
    // fill the tree only if this is the owner of the tree ... otherwise by TreeMaster
    FillTree();
}


//--------------------------------------------------------------------------/
//ClassImp(ADPSAHitTree);

ADPSAHitTree::ADPSAHitTree(const char *name, const char *title, TTree *tree) :
    PSAWatcher(name,title),
    TTreeBuilder(name,title,tree)
{
    if ( GetTree() ) { // just add the branch for that watcher
        SetBranches();
    }
}

ADPSAHitTree::~ADPSAHitTree()
{
}

void ADPSAHitTree::SetBranches()
{
    GetTree()->Branch("number_of_hits",&number_of_hits,"number_of_hits/I");
    GetTree()->Branch("hitE",hitE,"hitE[number_of_hits]/F");
    GetTree()->Branch("hitX",hitX,"hitX[number_of_hits]/F");
    GetTree()->Branch("hitY",hitY,"hitY[number_of_hits]/F");
    GetTree()->Branch("hitZ",hitZ,"hitZ[number_of_hits]/F");
    GetTree()->Branch("hitSg",hitSg,"hitSg[number_of_hits]/I");
    GetTree()->Branch("coreE0",&coreE0,"coreE0/F");
    GetTree()->Branch("coreE1",&coreE1,"coreE1/F");
    GetTree()->Branch("coreT0",&coreT0,"coreT0/F");
    GetTree()->Branch("coreT1",&coreT1,"coreT1/F");
    GetTree()->Branch("EvtNbr",     &fEfvtNbr,    "EvtNbr/I");
    GetTree()->Branch("TSHit",     &fTimestamp,    "TSHit/l");
}

void ADPSAHitTree::Exec(Option_t * /*option*/)
{
    if ( fFrame == 0x0 || !fFrame->IsValid() ) {
        SetLastExecStatus(1u);
        return;
    }

    fTimestamp = ((AgataKey *)fFrame->GetFrame()->GetKey())->GetTimeStamp();
    fEfvtNbr = ((AgataKey *)fFrame->GetFrame()->GetKey())->GetEventNumber();

    const PSAInterface *data = GetCstDataPointer<PSAInterface>(fFrame);

    number_of_hits = data->GetNbHits();
    coreE0 = data->GetE(0u);
    coreE1 = data->GetE(1u);
    coreT0 = data->GetT(0u);
    coreT1 = data->GetT(1u);

    for( UShort_t i=0u; i < number_of_hits; i++ )
    {
       hitSg[i] =  data->GetHit(i)->GetID(0);
       hitE[i] =  data->GetHit(i)->GetE();
       hitX[i] =  data->GetHit(i)->GetX();
       hitY[i] =  data->GetHit(i)->GetY();
       hitZ[i] =  data->GetHit(i)->GetZ();
    }
    FillTree();
}

void ADPSAHitTree::FillSpectraByUser()
{
    //Nothing yet.
}

void ADPSAHitTree::Print(Option_t * /*option*/ ) const
{
//    std::cout<<std::endl;
//    int size = 3 + 3 + ((TString)GetName()).Length() + 5 + ((TString)GetTitle()).Length() + 3 + 3;
//    for(int i=0; i<size ; i++) std::cout<<"*";
//    std::cout<<std::endl;
//    std::cout<<"***   "<<GetName()<<" --- "<<GetTitle()<<"   ***"<<std::endl;
//    for(int i=0; i<size ; i++) std::cout<<"*";
//    std::cout<<std::endl;
}


//--------------------------------------------------------------------------/
//ClassImp(ADCrystalTree);

ADCrystalTree::ADCrystalTree(const char *name, const char *title, TTree *tree) :
    ShowSignals(name,title),
    TTreeBuilder(name,title,tree)
{
    memset(SegmentTraces, 0, kNSG*sizeof(Float_t)*kNSamples);
    memset(CoreTraces, 0, kNCC*sizeof(Float_t)*kNSamples);

    for(int atseg = 0; atseg < kNSG; atseg++) {
        SegE[atseg] = 0;
        SegBaselines[atseg] = 0;
    }
    for(int atcore = 0; atcore < kNCC; atcore++) {
        CoreE[atcore] = 0;
        CoreBaselines[atcore] = 0;
    }

    if ( GetTree() ) { // just add the branch for that watcher
        SetBranches();
    }
}

ADCrystalTree::~ADCrystalTree()
{
}

void ADCrystalTree::SetBranches()
{
    GetTree()->Branch("SegmentTraces",      SegmentTraces,  Form("SegmentTraces[%d]/F",kNSG*kNSamples));
    GetTree()->Branch("CoreTraces",         CoreTraces,     Form("CoreTraces[%d]/F",kNCC*kNSamples));

    GetTree()->Branch("SegBaselines",       SegBaselines,   Form("SegBaselines[%d]/D",kNSG));
    GetTree()->Branch("SegE",               SegE,           Form("SegE[%d]/D",kNSG));

    GetTree()->Branch("CoreBaselines",      CoreBaselines,  Form("CoreBaselines[%d]/D",kNCC));
    GetTree()->Branch("CoreE",              CoreE,          Form("CoreE[%d]/D",kNCC));

    GetTree()->Branch("EvtNbr_crystal",     &fEfvtNbr,      "EvtNbr/I");
    GetTree()->Branch("TSHit_crystal",      &fTimestamp,    "TSHit/l");
}

void ADCrystalTree::Exec(Option_t * /*option*/)
{
    if ( fFrame == 0x0 || !fFrame->IsValid() ) {
        SetLastExecStatus(1u);
        return;
    }

    ShowSignals::Exec();

    fTimestamp = ((AgataKey *)fFrame->GetFrame()->GetKey())->GetTimeStamp();
    fEfvtNbr = ((AgataKey *)fFrame->GetFrame()->GetKey())->GetEventNumber();

    CrystalInterface *data = GetDataPointer<CrystalInterface>(fFrame);
    Float_t val = 0;

    for (Int_t i = 0; i < kNCC; i++ )
    {
        for(UInt_t j=0 ; j<kNSamples ; j++)
            CoreTraces[i*kNSamples+j] = data->GetCore(i)->GetSignal()->Get(val,j);

        CoreBaselines[i] = fFromSignal[0];
        CoreE[i] = data->GetCore(i)->GetE();
    }

    for (Int_t i = 0; i < kNSG; i++ )
    {
        for(UInt_t j=0 ; j<kNSamples ; j++)
        {
            SegmentTraces[i*kNSamples+j] = data->GetSegment(i)->GetSignal()->Get(val,j);
//            std::cout<<SegmentTraces[i][j]<<std::endl;
        }

        SegBaselines[i] = fFromSignal[0];
        SegE[i] = data->GetSegment(i)->GetE();
    }


//    for (Int_t i = 0; i < kNSG; i++ )
//    {
//        for(uint j=0 ; j<ADF::CrystalInterface::kDefaultLength ; j++)
//        {
//            std::cout<<SegmentTraces[i][j]<<std::endl;
//        }
//    }

//    std::cin.get();

    FillTree();
}

void ADCrystalTree::ConvertInGraph(TH1 *h, TGraph *g)
{
    for(int i=0 ; i<h->GetNbinsX() ; i++)
    {
        g->SetPoint(i,h->GetBinLowEdge(i+1),h->GetBinCenter(i+1));
    }
}

void ADCrystalTree::FillSpectraByUser()
{
    //Nothing yet.
}

void ADCrystalTree::Print(Option_t * /*option*/ ) const
{
    std::cout<<std::endl;
    int size = 3 + 3 + ((TString)GetName()).Length() + 5 + ((TString)GetTitle()).Length() + 3 + 3;
    for(int i=0; i<size ; i++) std::cout<<"*";
    std::cout<<std::endl;
    std::cout<<"***   "<<GetName()<<" --- "<<GetTitle()<<"   ***"<<std::endl;
    for(int i=0; i<size ; i++) std::cout<<"*";
    std::cout<<std::endl;
}