GSI/PSAWatchers.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.             *
 ***************************************************************************/

// Watcher definition
#ifndef _PSAWatchers
#include "PSAWatchers.h"
#endif

using namespace ADF;

ClassImp(PSAWatcher);

Bool_t PSAWatcher::SetTrigger(ADF::DFTrigger* trigger ) 
{
        return Watcher::GetFromTrigger(trigger, "data:psa", fFrame);
}

ClassImp(PSACrystal3D);

Float_t PSACrystal3D::fgMetric = 10.;
Float_t PSACrystal3D::fRadius = 5. ;
Float_t PSACrystal3D::fDepht = 10.;
Int_t PSACrystal3D::fNBinX = 50;
Int_t PSACrystal3D::fNBinZ = 50;
Float_t PSACrystal3D::fDefaultECutMin = 0.;
Float_t PSACrystal3D::fDefaultECutMax = 100000000.;


PSACrystal3D::PSACrystal3D( const char * name, const char * title, TDirectory *sp_dir, TDirectory *tag_dir):
        PSAWatcher(name,title,sp_dir,tag_dir),
        fH3DHitPosition(0x0),
        fE0(0x0),       
        fE1(0x0),       
        fT0(0x0),       
        fT1(0x0),
        fTE0(0x0),
        fTE1(0x0),      
        fEnergySeg(0x0),        
        fNbHits(0x0),   
        fCurrentECutMin(fDefaultECutMin),
        fCurrentECutMax(fDefaultECutMax)       
{
        fH3DHitPosition = MakeTH3<TH3F>("H3DHitPosition", "Distribution of Hits in the crystal; x (cm); y (cm); z (cm)",
                                                           fNBinX, -fRadius, fRadius,
                                                           fNBinX, -fRadius, fRadius,
                                                           fNBinZ, 0, fDepht );
        fE0 = MakeTH1<TH1F>("ECore0", "Core energy 0, (high gain)",6000, 0, 6000);
    fE1 = MakeTH1<TH1F>("ECore1", "Core energy 1, (low gain) ",1000, 0, 10000);
    fE1->SetLineColor(kRed);
        fT0 = MakeTH1<TH1F>("TCore0", "Core time 0",300, 0, 100);
        fT1 = MakeTH1<TH1F>("TCore1", "Core time 1",300, 0, 100);
    fT1->SetLineColor(kRed);
    fTE0 = MakeTH2<TH2F>("TECore0", "Time energy 0",600,0,6000,300, 0, 100);
    fTE1 = MakeTH2<TH2F>("TECore1", "Time energy 1",600, 0,6000,300, 0, 100);

        fEnergySeg  = MakeTH1<TH1F>("ESum", "Sum of segment",6000, 0, 6000);
        fNbHits     = MakeTH1<TH1F>("NbHits", "Nb hits in crystal",20, 0, 20);
}

PSACrystal3D::~PSACrystal3D()
{
                ;
}


void PSACrystal3D::DoCanvas(TCanvas * c, Option_t *o)
{
        TString option = o;
    if ( option == "3D" ) {
                fH3DHitPosition->Draw(o);       
    }
    else {
        c->Divide(3,2);
        c->cd(1);
        fE0->Draw();
        c->cd(2);
        fE1->Draw();
        c->cd(3);
        fEnergySeg->Draw();
        c->cd(4);
        fT0->Draw();
        fT1->Draw("same");
        c->cd(5);
        fTE0->Draw("col");
        c->cd(6);
        fTE1->Draw("col");
    }
}

void PSACrystal3D::Exec(Option_t * /*option*/)
{
        // be sure the frame has been set properly
        if ( fFrame == 0x0 || !fFrame->IsValid() ) 
                { SetLastExecStatus(-1); return; }
        
        const PSAInterface *data = GetCstDataPointer<PSAInterface>(fFrame); 
        
        Double_t e = 0.;
        for( UShort_t i=0u; i < data->GetNbHits(); i++ ) {
                e +=  data->GetHit(i)->GetE();
                if( data->GetHit(i)->GetE() >= fCurrentECutMin && data->GetHit(i)->GetE() <= fCurrentECutMax )
                        fH3DHitPosition->Fill(data->GetHit(i)->GetX()/fgMetric,
                                                data->GetHit(i)->GetY()/fgMetric,
                                                data->GetHit(i)->GetZ()/fgMetric);
        }
        fNbHits->Fill(data->GetNbHits());
        fE0->Fill(data->GetE(0u));
        fE1->Fill(data->GetE(1u));
        fT0->Fill(data->GetT(0));
        fT1->Fill(data->GetT(1));
        fTE0->Fill(data->GetE(0u),data->GetT(0));
        fTE1->Fill(data->GetE(1u),data->GetT(1));
        fEnergySeg->Fill(e);
}

void PSACrystal3D::SetEnergyCut( Float_t EcutMin,Float_t EcutMax ){
        if( EcutMax < EcutMin ) {
                std::cerr << "ERROR: PSACrystal3D::SetEnergyCut( Float_t EcutMin,Float_t EcutMax)"
                << std::endl
                << "ECutMin greater than ECutMax, the cut has not been changed : "
                << "ECutMin = " << fCurrentECutMin
                << "  EcutMax = " << fCurrentECutMax << std::endl;
                return;
        }
        
        if( EcutMin != fCurrentECutMin && EcutMax != fCurrentECutMax ) {
                fCurrentECutMin = EcutMin;
                fCurrentECutMax = EcutMax;
                fH3DHitPosition->Reset();
                TString newtitle = Form("Distribution of Hits in the crystal E #in [%lf,%lf]; x (cm); y (cm); z (cm)",
                                                                EcutMin,
                                                                EcutMax);
                fH3DHitPosition->SetTitle(newtitle.Data());
        }
}

void PSACrystal3D::SetCurrentECutMin( Float_t EcutMin )
{
        fCurrentECutMin = EcutMin;
}
void PSACrystal3D::SetCurrentECutMax( Float_t EcutMax )
{
        fCurrentECutMax = EcutMax;
}
Float_t PSACrystal3D::GetCurrentECutMin() const
{
        return(fCurrentECutMin);
}
Float_t PSACrystal3D::GetCurrentECutMax() const
{
        return(fCurrentECutMax);
}