GammaTracker.cpp

Go to the documentation of this file.

#ifndef ROOT_TClass
#include <TClass.h>
#endif

#ifndef ROOT_TROOT
#include <TROOT.h>
#endif

#ifndef ROOT_TSystem
#include <TSystem.h>
#endif

#ifndef GW_GAMMATRACKER_H
#include "GammaTracker.h"
#endif

#include <iostream>

#define MAXIMPACTS 1000

using namespace Gw;
using namespace std;

ClassImp(GammaTracker);

GammaTracker::GammaTracker(const char *name,const char *title) : TNamed(name,title)
{
//      fDoPacking = fDoSmearing = kTRUE;
        MaxImpacts = MAXIMPACTS;

        InputN  = 0;    
        InputE  = new Double_t[MaxImpacts]; ::memset(InputE,0,sizeof(Double_t)*MaxImpacts);
        InputDE = new Double_t[MaxImpacts]; ::memset(InputDE,0,sizeof(Double_t)*MaxImpacts);    

        InputX  = new Double_t[MaxImpacts]; ::memset(InputX,0,sizeof(Double_t)*MaxImpacts);
        InputY  = new Double_t[MaxImpacts]; ::memset(InputY,0,sizeof(Double_t)*MaxImpacts);
        InputZ  = new Double_t[MaxImpacts]; ::memset(InputZ,0,sizeof(Double_t)*MaxImpacts);
        InputDX = new Double_t[MaxImpacts]; ::memset(InputDX,0,sizeof(Double_t)*MaxImpacts);
        InputDY = new Double_t[MaxImpacts]; ::memset(InputDY,0,sizeof(Double_t)*MaxImpacts);
        InputDZ = new Double_t[MaxImpacts]; ::memset(InputDZ,0,sizeof(Double_t)*MaxImpacts);
        
        OutputN  = 0;   
        OutputE      = new Double_t[MaxImpacts];  ::memset(OutputE,0,sizeof(Double_t)*MaxImpacts);
        OutputTheta1 = new Double_t[MaxImpacts];  ::memset(OutputTheta1,0,sizeof(Double_t)*MaxImpacts); 
        OutputPhi1   = new Double_t[MaxImpacts];  ::memset(OutputPhi1,0,sizeof(Double_t)*MaxImpacts);   
        OutputTheta2 = new Double_t[MaxImpacts];  ::memset(OutputTheta2,0,sizeof(Double_t)*MaxImpacts);
        OutputPhi2   = new Double_t[MaxImpacts];  ::memset(OutputPhi2,0,sizeof(Double_t)*MaxImpacts);           
}

GammaTracker::~GammaTracker()
{
        if ( InputE )  { delete [] InputE; InputE = NULL; }
        if ( InputX )  { delete [] InputX; InputX = NULL; }
        if ( InputY )  { delete [] InputY; InputY = NULL; }
        if ( InputZ )  { delete [] InputZ; InputZ = NULL; }
        if ( InputDX ) { delete [] InputDX; InputDX = NULL; }
        if ( InputDY ) { delete [] InputDY; InputDY = NULL; }
        if ( InputDZ ) { delete [] InputDZ; InputDZ = NULL; }
        
        if ( InputDE ) { delete [] InputDE; InputDE = NULL; }

        if ( OutputE )     { delete [] OutputE;     OutputE = NULL; }
        if ( OutputTheta1 ){ delete [] OutputTheta1;OutputTheta1 = NULL; }      
        if ( OutputPhi1 )  { delete [] OutputPhi1;  OutputPhi1   = NULL; }
        if ( OutputTheta2) { delete [] OutputTheta2;OutputTheta2 = NULL; }
        if ( OutputPhi2 )  { delete [] OutputPhi2;  OutputPhi2 = NULL; }
}

bool GammaTracker::Load(const char *classname, const char *pathtopackage, const char *libraryname)
{
        if ( GammaTracker::IsTracker(classname) ) return true;
        
        TString name = classname, path = pathtopackage, libname = libraryname, tmp;

        if ( path.EndsWith("/") == kFALSE ) path += "/"; 
        
        // load the dynamic library
        tmp = path + libname; 
        if ( gSystem->Load(tmp.Data()) < 0 ) {
                cout << "Cannot find library " << libname << " in " << path << endl; return false; 
        }
                
        // add path to includes to compile the wrapper
        tmp = ".include " + path ; gROOT->ProcessLine(tmp.Data());
        
        // try to compile the wrapper class
        tmp = ".L "; tmp += classname; tmp += "Adapter.C+";
        cout << " Trying to compile the Adapter: " << tmp << endl; gROOT->ProcessLine(tmp);
        
        // test if the class is now available
        if ( GammaTracker::IsTracker(classname) ) {
                cout << " " << classname << " is now available though GammaTracker::GetTracker " << endl; return true;
        }
        else {
                cout << " " << classname << " is NOT available though GammaTracker::GetTracker " << endl; return false; 
        }
}
                

GammaTracker *GammaTracker::GetTracker(const char *classname)
{
        GammaTracker *tracker = NULL;
        
        // known by the ROOT dictionnary
        TClass *cl = gROOT->GetClass(classname);
        if ( cl  ) { tracker = (GammaTracker *)cl->New(); }
        
        return tracker;
}


UInt_t  GammaTracker::SetEvent(UInt_t n, const Double_t *e, const Double_t *x, const Double_t *y, const Double_t *z, Double_t efactor, Double_t pfactor)
{
        UInt_t i;
        if ( n > (MaxImpacts-1) ) { InputN = 0; return InputN; } // to protect against too large input

        InputN = n;
        if ( efactor == 1.0 ) { // no multiplication factor required
                ::memcpy(InputE,e,sizeof(Double_t)*InputN); // no multiplication factor required
        }
        else {
                for (i = 0; i < InputN; i++ ) { InputE[i] = e[i] * efactor; }
        }       
        
        if ( pfactor == 1.0 ) { // no multiplication factor required
                ::memcpy(InputX,x,sizeof(Double_t)*n); 
                ::memcpy(InputY,y,sizeof(Double_t)*n); 
                ::memcpy(InputZ,z,sizeof(Double_t)*n); 
        } 
        else {
                for (i = 0; i < InputN; i++ ) { 
                        InputX[i] = x[i] * pfactor;
                        InputY[i] = y[i] * pfactor;
                        InputZ[i] = z[i] * pfactor;     
                }
        }
        ::memset(InputDE,0,sizeof(Double_t)*MaxImpacts); 
        ::memset(InputDX,0,sizeof(Double_t)*MaxImpacts); 
        ::memset(InputDY,0,sizeof(Double_t)*MaxImpacts); 
        ::memset(InputDZ,0,sizeof(Double_t)*MaxImpacts);
        
        return InputN;
}
void GammaTracker::ShowCurrentEvent()
{
        cout << " list of inputs for GammaTracker " << endl;
        for (UInt_t i = 0; i < InputN; i++ ) {
                cout << " " << InputE[i] << endl;
                cout << " " << InputX[i] << " " << InputY[i] << " " << InputZ[i] << endl;
                
        }
        cout << " list of outputs for GammaTracker " << endl;
        for (UInt_t i = 0; i < OutputN; i++ ) {
                cout << " " << OutputE[i] << endl;              
                cout << " " << OutputTheta1[i] << " " << OutputPhi1[i] << " " << OutputTheta2[i] << " " << OutputPhi2[i] <<endl;
        }
        
}

Int_t GammaTracker::DoTracking()
{
        if ( InputN == 0 ) { OutputN = 0; return OutputN; }

        OutputN = 1; OutputE[0] = 0.0;
        for (UInt_t i = 0; i < InputN; i++) { OutputE[0] += InputE[i]; }

        return OutputN;
}