source: JEM-EUSO/esaf_lal/tags/v1_r0/esaf/packages/reconstruction/framework/src/ModuleFactory.cc @ 117

// ESAF : Euso Simulation and Analysis Framework
// $Id: ModuleFactory.cc 3011 2012-01-27 15:31:18Z biktem $
// Marco Pallavicini created Oct, 16 2003


#include "utils.hh"
#include "ModuleFactory.hh"
#include "TestRecoModule.hh"
#include "TestInputModule.hh"
#include "RootInputModule.hh"
#include "LTTPreClusteringModule.hh"
#include "HoughModule.hh"
#include "BaseClusteringModule.hh"
#include "ClusterAnalysisModule.hh"
#include "GTUClusteringModule.hh"
#include "TrackDirection2Module.hh"
#include "TrackDetectorPlaneModule.hh"
#include "TrackDirectionModule.hh"
#include "HmaxForProtonModule.hh"
#include "EnergyModule.hh"
#include "JemEnergyModule.hh"
#include "ProfileModule.hh"
#include "PmtToShowerReco.hh"
#include "RobustModule.hh"
#include <fstream>
#include <TMinuit.h>
#include <TVector3.h>

ClassImp(ModuleFactory)

// constructor
ModuleFactory::ModuleFactory(const string& sName) {
        
        fCurrent = 0;
        fInputModule = 0;
        
        ifstream in( sName.c_str() );
        if (!in) {
                Msg(EsafMsg::Panic) << "Cannot find the list of modules in " << sName<< MsgDispatch;
        }
        
        string dummy;
        
        // parse file
        while ( getline(in,dummy) ) {
                // erase comments
                size_t pos = dummy.find('#');
                if ( pos != string::npos ) 
                        dummy.erase( pos );
                
                // swallow spaces
                        dummy = ltrim( dummy );
                        
                        // skip blank lines
                        if ( dummy.empty() ) continue;
                        
                        // each line must be a key=value pair
                        // key can be : InputModule, Module, Sequence
                        // InputModule: specifies the unique input module; 
                        // Module: normal module
                        // Sequence: list of connected modules (not implemented yet)
                        
                        // get identifier
                        string identifier = dummy.substr( 0, dummy.find('=') );
                        identifier = rtrim( identifier );
                        if ( identifier.find_first_of("\t ") != string::npos) {
                                throw runtime_error("Syntax error in file "+sName+" line "+dummy);
                        }
                        
                        // get module name
                        string name = dummy.substr( dummy.find('=')+1, string::npos);
                        name = trim( name );
                        
                        // build modules
                        if ( identifier == "InputModule" ) {
                                MakeInputModule(name);
                        }
                        else if ( identifier == "Module" ) {
                                MakeModule( name );
                        }
                        else if ( identifier == "Sequence" ) {
                                MakeSequence( name );
                        }
                        else {
                                throw runtime_error("Syntax error in file"+sName+" line "+dummy);
                        }
                        
        }
}

// destructor
ModuleFactory::~ModuleFactory() {
}

// returns a module until the list is over
RecoModule* ModuleFactory::GetModule() {
        if ( fCurrent < fModules.size() )
                return fModules[fCurrent++];
        else
                return (RecoModule*)0;
}

// physically build objects and store into a vector
void ModuleFactory::MakeModule( const string& name) {
        if ( name == "Test1" )
                fModules.push_back( new TestRecoModule( name ) );
        else if ( name == "Test2" )
                fModules.push_back( new TestRecoModule( name ) );
        else if ( name == "Test3" )
                fModules.push_back( new TestRecoModule( name ) );
        else if ( name == "RobustModule" )
                fModules.push_back( new RobustModule() );
        // real modules begin here!!
        else if ( name == "LTTPreClustering" )
                fModules.push_back( new LTTPreClusteringModule() );
        else if ( name == "HoughTransform" )
                fModules.push_back( new HoughModule() );
        else if ( name == "BaseClustering" )
                fModules.push_back( new BaseClusteringModule() );
        else if ( name == "ClusterAnalysis" )
                fModules.push_back( new ClusterAnalysisModule() );
        else if ( name == "GTUClustering" )
                fModules.push_back( new GTUClusteringModule() );
        else if ( name == "TrackDirection2" )
                fModules.push_back( new TrackDirection2Module() );
        else if ( name == "TrackDetectorPlane" )
                fModules.push_back( new TrackDetectorPlaneModule() );
        else if ( name == "TrackDirection" )
                fModules.push_back( new TrackDirectionModule() );
        else if ( name == "HmaxForProton" )
                fModules.push_back( new HmaxForProtonModule() );
        else if ( name == "Energy" )
                fModules.push_back( new EnergyModule() );
        else if ( name == "JemEnergy" )
                fModules.push_back( new JemEnergyModule() );
        else if ( name == "Profile" )
                fModules.push_back( new ProfileModule() );
        else if ( name == "PmtToShowerReco" )
                fModules.push_back( new PmtToShowerReco() );
        else
                throw runtime_error("Unknown Module:"+name);
}

// physically build objects and store into a vector
void ModuleFactory::MakeInputModule( const string& name) {
        if ( name == "Test" )
                fInputModule = new TestInputModule( name );
        else if ( name == "Root" )
                fInputModule = new RootInputModule();
        else
                throw runtime_error("Unknown Input Module:"+name);
}

// sequences: to be done
void ModuleFactory::MakeSequence( const string& name) {
}