GANIL/MetaWatchers.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
#include "MetaWatchers.h"
#include "GenericFrame.h"

using namespace ADF;

VertexBuilder *VertexBuilder::gDefautVertexBuilder = 0x0;
UShort_t VertexBuilder::gNbVertexBuilder = 0u;  

VertexBuilder::VertexBuilder() :
fVertexFrame(0x0),
fIsToBeDeleted(false)
{ 
        gNbVertexBuilder++; 
        // NO otherwise endless loop    VertexBuilder::theDefault(); 
}

VertexBuilder::~VertexBuilder()
{               
        if ( fIsToBeDeleted ) {
                if ( fVertexFrame ) {
                        delete fVertexFrame; fVertexFrame = 0x0;
                }
        }
        
        // now take care of the globals
        gNbVertexBuilder--;
        
        // last VertexBuilder delete the globals otherwise the user should call explicitely DestroyGlobals
        if ( gNbVertexBuilder == 0u ) 
                DestroyGlobals();
}

VertexBuilder *VertexBuilder::theDefault()
{
        if ( gDefautVertexBuilder == 0x0 ) {
                GlobalVertex *vertex =  
                        new GlobalVertex("GCVertex","Global Constant Vertex");
                vertex->SetVertex();
                
                Watcher::SetFirst(vertex);
                
                gDefautVertexBuilder = vertex;
        }
        return gDefautVertexBuilder;
}

VertexBuilder *VertexBuilder::theCurrentVertexBuilder()
{
        VertexBuilder *result_b = 0x0;
        
        if ( gDefautVertexBuilder == 0x0 ) 
                VertexBuilder::theDefault();
        
        Watcher *w = 
                Watcher::GetLastRegistered("VertexBuilder");
        result_b = 
                dynamic_cast<VertexBuilder *> (w);
        
        return result_b;        
}

void VertexBuilder::DestroyGlobals()
{       
        if ( gDefautVertexBuilder )
        { delete gDefautVertexBuilder; gDefautVertexBuilder = 0x0; }
}

void VertexBuilder::SetVertex
(Double_t x,Double_t y,Double_t z,Double_t Dx,Double_t Dy,Double_t Dz,Double_t beta)
{       
        VertexInterface *gdata = GetDataPointer<VertexInterface>(fVertexFrame);
        
        gdata->SetPosition(x,y,z);
        gdata->SetDirection(Dx,Dy,Dz);  
        gdata->SetBeta(beta);         
} 


ClassImp(GlobalVertex);

GlobalVertex::GlobalVertex(const char *name, const char *title, TDirectory *sp_dir, TDirectory *tag_dir) : 
WatcherWithTag(name,title,sp_dir,tag_dir),
VertexBuilder()
{
        fVertexFrame = MainFrameFactory::theMainFactory().
            NewSharedFrame( FactoryItem("Agata","meta:vertex",Version(0,0)), FactoryItem("Agata","meta:vertex",Version(1,1)) );
        
        fIsToBeDeleted = true;
}

GlobalVertex::~GlobalVertex()
{
        
}

ClassImp(GlobalDC);

GlobalDC::GlobalDC(const char *name, const char *title, TDirectory *sp_dir, TDirectory *tag_dir) : 
        WatcherWithTag(name,title,sp_dir,tag_dir),
        fBeta(0x0),
        fPosition(0x0),
        fExpansion(0x0),
        fDirection(0x0)
{
        fVertexBuilder = dynamic_cast<VertexBuilder *> ( Watcher::GetLastRegistered("VertexBuilder") );
        
        fBeta = MakeTH1<TH1F>("Beta","Beta ",500,0.,1.0);
        TagOn(fBeta);
        
        fPosition  = MakeTH3<TH3F>("VertexP","Position of the vertex;x;y;z",50,-50.,50.,50,-50.,50.,50,-50.,50.);
        fExpansion = MakeTH3<TH3F>("VertexE","Expansion of the vertex ;x;y;z",100,-200.,200.,100,-200.,200.,100,-500.,7000.);
        fDirection = MakeTH3<TH3F>("VertexD","Direction of the recoil nucleus;dx;dy;dz",50,-1.,1.,50,-1.,1.,50,-1.,1.);
}

GlobalDC::~GlobalDC()
{
}

void GlobalDC::DoCanvas(TCanvas *c, Option_t *o)
{
        TString opt = o;
        if ( opt.Contains("tag") ) {
                DrawTag(c,opt);
                return;
        }
}

Bool_t GlobalDC::SetTrigger( ADF::DFTrigger *trigger ) 
{
        Watcher::SetTrigger(trigger);   
        return true; 
        // this watcher does not need a Frame, just to trigg ... it just take the values from static methods of VertexBuilder
}

void GlobalDC::Exec(Option_t */*option*/) 
{
        Double_t x, y, z, wx, wy, wz,dx, dy, dz, beta;
    
        if ( gDebug > 3 )
                printf("GlobalDC::Exec is called \n");
        
        VertexInterface *vertex = fVertexBuilder->GetVertex();
    beta = vertex->GetBeta();
    
    //  cout << " --> " << VertexBuilder::theCurrentVertex()->GetBeta() << endl;
        
    //  if ( VertexBuilder::theCurrentVertex()->GetBeta() > 0.00) {
        vertex->GetPosition(x,y,z);
        vertex->GetDirection(dx,dy,dz);
    wx=beta*dx+x;
    wy=beta*dy+y;
    wz=beta*dz+z;
    
        fBeta->Fill(beta);
        fPosition->Fill(x,y,z);
    fExpansion->Fill(wx,wy,wz);
        fDirection->Fill(dx,dy,dz);
//      }       
}