/Users/fpy/titan-1-5-MBARI/Mers/Executives/DeductiveController/Configs/DC_1_3-Standalone/DCTest.cpp

//
// Copyright (c) 2004           Model-based Embedded and Robotic Systems Group
// All Rights Reserved          Massachusetts Institute of Technology
//
// This software is provided as is. Model-based Embedded and Robotic Systems
// (MERS) group does not assume any responsibility.
//
// Organization:        Model-based Embedded and Robotic Systems Group
//                                      Massachusetts Institute of Technology
//

#include <Mers/Utils/Io/Xml/Sax/XMLLoader.h>


#ifdef FAILED
#undef FAILED
#endif


#include <Mers/Estimation/Discrete/ApproximateBeliefState/BFBSU/BFBSU.h>
#include <Mers/Estimation/Discrete/ProbabilityRules/RuleGenerator/ProbRuleGenerator.h>
#include <Mers/Estimation/Discrete/CompiledME/CCMEReader/CCMEReader.h>
#include <Mers/Estimation/Discrete/MEInterface.h>
#include <Mers/Solvers/Entailment/GI/GoalInterpreter.h>
#include <Mers/Models/CCA/CCAModel.h>
#include <Mers/Executives/DeductiveController/DCInterface.h>
#include <Mers/Estimation/Discrete/Trajectories.h>
#include <Mers/Estimation/Discrete/Io/Xml/Sax/TrajCH.h>
#include <Mers/Reconfiguration/Discrete/modeReconfiguration.h>
#include <Mers/Reconfiguration/Discrete/mrInterface.h>
#include <vector>


using Mers::Models::CCA::CCAModel;
using Mers::Models::Base::BaseModel;
using Mers::Estimation::Discrete::MEInterface;
using Mers::Estimation::Discrete::ApproximateBeliefState::BFBSU::BFBSU;
using Mers::Estimation::Discrete::ProbabilityRules::RuleGenerator::ProbRuleGenerator;
using Mers::Estimation::Discrete::ProbabilityRules::ObsProbRule;
using Mers::Estimation::Discrete::CompiledME::CCMEReader::CCMEReader;
using Mers::Estimation::Discrete::Dissent;
using Mers::Estimation::Discrete::ME_connection;
using Mers::Solvers::Entailment::GoalInterpreterInterface;
using Mers::Solvers::Entailment::GI::GoalInterpreter;
using Mers::Executives::DeductiveController::DCInterface;
using Mers::Estimation::Discrete::Trajectories;
using Mers::Estimation::Discrete::Io::Xml::Sax::TrajCH;
using Mers::Utils::Io::Xml::Sax::XMLLoader;
using Mers::Reconfiguration::Discrete::MR_connection;
// using Mers::Reconfiguration::Discrete::mrInterface;
// using Mers::Reconfiguration::Discrete::modeReconfiguration;
using std::vector;


void printUse( const char * progName )
{
        printf("Use: %s <CCA file> <ME Init file> <CCME file> [<log4cplus file>]\n", progName);
}


bool requiredParameters(int argc, const char * progName) {
        if(argc != 3 && argc != 4){
                printUse( (progName == NULL ? "DCTest" : progName) );
                return false;
        } else {
                return true;
        }
}


class Arguments
{
public:
        CCAModel * ccaModel;
        const char * modelFileName;
        const char * trajFileName;
        const char * obsProbsFileName;
        const char * log4cplusFileName;
};


CCAModel *      load_MOF(char const * MOF_file_name);


Arguments * loadParameters(int argc, const char * argv[]) {
        Arguments * args = new Arguments();
        args->ccaModel = load_MOF(argv[0]);
        args->modelFileName = argv[0];
        args->trajFileName = argv[1];
        args->obsProbsFileName = argv[2];
        if(argc > 3)
                args->log4cplusFileName = argv[3];
        else
                args->log4cplusFileName = NULL;
        return args;
}


ME_connection * constructME(Arguments * args) {
        Trajectories * trajs;
        // Load the Trajectories.
        if( FAILED(
                XMLLoader::load< Trajectories *, const BaseModel *, TrajCH >
                ( args->trajFileName, trajs, args->ccaModel ) ) )
        {
                trajs = NULL;
        }

        // Load the CCME file
        CCMEReader reader;
        if( FAILED( reader.loadCCMEFile( args->obsProbsFileName, *args->ccaModel) ) )
        {
                fprintf(stderr, "Could not load \"%s\".\n", args->obsProbsFileName);
                exit(-1);
        }

        // Get our dissents and transitions.
        vector<const Dissent *> dissents = reader.getDissents();

        // Get the probability rules
        ProbRuleGenerator * myPRG =
                new ProbRuleGenerator(args->ccaModel, dissents, 1);
        vector<const ObsProbRule *> obsProbabilityRules =
                myPRG->getObservationRules();

        BFBSU * me = new BFBSU(*(args->ccaModel), obsProbabilityRules, trajs);

        return new MEInterface( me );
}


GoalInterpreterInterface * constructGI(Arguments * args) {
        return new GoalInterpreter(args->ccaModel);
}


MR_connection * constructMR(Arguments * args) {
        modeReconfiguration * mr =
                new modeReconfiguration( *args->ccaModel, constructGI( args ) );
        return new mrInterface( *mr );
}


void CreateChildren( Arguments * args, DCInterface * dc ) {
        // Don't have any children to create.
        (void) args;
        (void) dc;
}


#include <Mers/Executives/DeductiveController/DeductiveController.cpp>

---