Base_Setup.h

Go to the documentation of this file.

//     Authors:
// Anselmo Cervera, Juan J. Gomez-Cadenas and Jose Angel Hernando

#ifndef Setup_h
#define Setup_h 1


#include "Kalman/Base_VolumeB.h"
#include "Kalman/Base_SurfaceB.h"
#include "Kalman/Base_SurfaceServer.h"
#include "Kalman/Base_LogicB.h"
#include "Kalman/Base_TrajectoryEngine.h"
#include "Kalman/Interface_IState.h"

class Setup
{
 public:

  //! default constructor
  Setup(TrajectoryEngine* engine){
    m_engine = engine; 
    m_defaultVolume = new VolumeB("default");
    m_logicName = "";
  }
  
  //! default destructor
  virtual ~Setup(){delete m_defaultVolume;}
  
 public:

  // TODO (what happens with const?
  virtual bool checkAllowedVolumeProperties(std::vector<std::string>& allowedProperties);
  virtual bool checkAllowedSurfaceTypes(std::vector<std::string>& allowedSurfaces);


  //-------------- SURFACE SERVER --------------------------

  //! Returns a reference to the server
  virtual SurfaceServer& surfaceServer(std::string name="")
     {return *m_surfServerMap[name];}; 
  //! set a Surface server with name
  virtual void addSurfaceServer(std::string name, SurfaceServer* ms) 
    {m_surfServerMap[name]=ms;}


  //! Add Surface to server
  virtual void addSurface(std::string name, ISurface& is)
    {m_surfServerMap[name]->addSurface(is);} 
  //! gets  Surface from server provided the server name and the surface index
  virtual ISurface& surface(std::string name, int i)
    {return m_surfServerMap[name]->surface(i);} 
  //! gets  Surface from server provided the server name and the surface mainParameter
  virtual ISurface& surface(std::string name, double z)
    {return m_surfServerMap[name]->surface(z);} 

  //! gets  the number of Surfaces in the server
  virtual int nSurfaces(std::string name) 
    {return m_surfServerMap[name]->nSurfaces();} 


  //------------  VOLUME MAP -----------------------------

  //! Returns a reference to the volume of name 
  virtual IVolume& volume(std::string name){
    if (name == "default") return *m_defaultVolume;
    else return *m_volumeMap[name]; 
  }

  //! Check if the volume has been defined 
  virtual bool volumeExists(std::string name){
    if (m_volumeMap.count(name) != 0) return true;
    else return false;
  } 
  
  
  
  //! Returns a reference to the father volume
  virtual IVolume& fatherVolume(std::string name="")
    {return m_volumeMap[name]->father();} 


  //! add a new volume 
  virtual void addVolume(std::string name, IVolume& vol){ 
    vol.setFather(*m_defaultVolume); 
    vol.setMainParameter(m_defaultVolume->mainParameterName(),
             m_defaultVolume->mainParameterVector(),
             m_defaultVolume->mainParameterComponent());
    m_volumeMap[name]=&vol;
  }
  virtual void addVolume(std::string name, std::string type, EVector pos, EVector size, 
             EVector dir1)
    {addVolume(name, *(engine().newVolume(name, type, pos, size, dir1)));}  

  virtual void addVolume(std::string name, std::string type, EVector pos, EVector size, 
             EVector dir1, EVector dir2)
    {addVolume(name, *(engine().newVolume(name, type, pos, size, dir1, dir2)));}  
  



  //! add a real copy of a volume definition
  virtual void addVolumeCopy(std::string name, std::string type, EVector pos);

  
  //! add a child  volume  to an existing volume
  virtual void addVolumeToVolume(std::string father, IVolume& vol);
  virtual void addVolumeToVolume(std::string father, std::string name, std::string type, 
                 EVector pos, EVector size, EVector dir1);
  virtual void addVolumeToVolume(std::string father, std::string name, std::string type, 
                 EVector pos, EVector size, EVector dir1, EVector dir2);


  //! add a child  surface  to an existing volume
  virtual void addSurfaceToVolume(std::string volName, ISurface& surf); 
  virtual void addSurfaceToVolume(std::string volName, std::string type, 
                  EVector pos, EVector size, EVector dir1)
    {addSurfaceToVolume(volName, *(new SurfaceB(type, pos, size, dir1)));} 
  virtual void addSurfaceToVolume(std::string volName, std::string type, 
                  EVector pos, EVector size, EVector dir1, EVector dir2) 
    {addSurfaceToVolume(volName, *(new SurfaceB(type, pos, size, dir1, dir2)));} 

  //! gets  Surface from volume provided the volume name and the surface index
  virtual ISurface& surfaceInVolume(std::string name, int i)
    {return volume(name).childSurface(i);} 
  //! gets  Surface from volume provided the volume name and the surface name
  //  virtual ISurface& surfaceInVolume(std::string volName, std::string surfName)
  //    {return volume(volName).childSurface(surfName);} 


   //! main parameter of a volume
  virtual void setMainParameterInVolume(std::string volName, std::string name, std::string vectorName, int comp)
    {volume(volName).setMainParameter(name, vectorName, comp);}

  //! volume at  a given mainParameter
  virtual std::string volumeAtMainParameter(double z);

  //! volume at  a given position
  virtual std::string volumeAtPosition(double x, double y, double z);

 //! set properties of the volume in the case there is a choice
  virtual void addVolumeProperty(std::string volName, std::string propName, int prop)
     {m_volumeMap[volName]->addProperty(propName, prop);} 
  virtual void addVolumeProperty(std::string volName, std::string propName, double prop)
     {m_volumeMap[volName]->addProperty(propName, prop);} 
  virtual void addVolumeProperty(std::string volName, std::string propName, EVector& prop)
     {m_volumeMap[volName]->addProperty(propName, prop);} 
  virtual void addVolumeProperty(std::string volName, std::string propName, EMatrix& prop)
     {m_volumeMap[volName]->addProperty(propName, prop);} 
  virtual void addVolumeProperty(std::string volName, std::string propName, std::string prop)
     {m_volumeMap[volName]->addProperty(propName, prop);} 

  virtual void addVolumePropertyPointer(std::string volName, std::string propName, void* prop)
     {m_volumeMap[volName]->addPropertyPointer(propName, prop);} 



  //------------ VOLUME DEFINITION ----------------------------

  //! Returns a reference to the volume of name 
  virtual IVolume& volumeDefinition(std::string name)
    {return *m_volumeDefMap[name];} 
  
  //! Returns a reference to the volume of name 
  virtual bool volumeDefinitionExists(std::string name){
    if (m_volumeDefMap.count(name) != 0) return true;
    else return false;
  } 


  //! add a new volume 
  virtual void addVolumeDefinition(std::string name, IVolume& vol){ 
    vol.setMainParameter(m_defaultVolume->mainParameterName(),
             m_defaultVolume->mainParameterVector(),
             m_defaultVolume->mainParameterComponent());
    m_volumeDefMap[name]=&vol;
  }
  virtual void addVolumeDefinition(std::string name, std::string type, EVector size, EVector dir1)
    {addVolumeDefinition(name, *(new VolumeB("definition", name, type, size, dir1)));}
  virtual void addVolumeDefinition(std::string name, std::string type, EVector size, 
                   EVector dir1, EVector dir2)
    {addVolumeDefinition(name, *(new VolumeB("definition", name, type, size, dir1, dir2)));}  


  //! add a child  volume  to an existing volume 
  virtual void addVolumeToVolumeDefinition(std::string father, IVolume& vol);
  virtual void addVolumeToVolumeDefinition(std::string father, std::string name, std::string type, 
                       EVector pos, EVector size, EVector dir1)
    {addVolumeToVolumeDefinition(father, *engine().newVolume(name, type, pos, size, dir1));}  

  virtual void addVolumeToVolumeDefinition(std::string father, std::string name, std::string type, 
                       EVector pos, EVector size, EVector dir1, EVector dir2)
    {addVolumeToVolumeDefinition(father, *engine().newVolume(name, type, pos, size, dir1, dir2));}  


  //! add a child  surface  to an existing volume
  virtual void addSurfaceToVolumeDefinition(std::string volName, ISurface& surf);
  virtual void addSurfaceToVolumeDefinition(std::string volName, std::string type, 
                        EVector pos, EVector size, EVector dir1)
    {addSurfaceToVolumeDefinition(volName, *(new SurfaceB(type, pos, size, dir1)));} 

  virtual void addSurfaceToVolumeDefinition(std::string volName, std::string type, 
                        EVector pos, EVector size, EVector dir1, EVector dir2)
    {addSurfaceToVolumeDefinition(volName, *(new SurfaceB(type, pos, size, dir1, dir2)));} 


 //! set properties of the volume in the case there is a choice
  virtual void addVolumeDefinitionProperty(std::string volName, std::string propName, int prop)
     {m_volumeDefMap[volName]->addProperty(propName, prop);} 
  virtual void addVolumeDefinitionProperty(std::string volName, std::string propName, double prop)
     {m_volumeDefMap[volName]->addProperty(propName, prop);} 
  virtual void addVolumeDefinitionProperty(std::string volName, std::string propName, EVector& prop)
     {m_volumeDefMap[volName]->addProperty(propName, prop);} 
  virtual void addVolumeDefinitionProperty(std::string volName, std::string propName, EMatrix& prop)
     {m_volumeDefMap[volName]->addProperty(propName, prop);} 
  virtual void addVolumeDefinitionProperty(std::string volName, std::string propName, std::string prop)
     {m_volumeDefMap[volName]->addProperty(propName, prop);} 

  virtual void addVolumeDefinitionPropertyPointer(std::string volName, std::string propName, void* prop)
     {m_volumeDefMap[volName]->addPropertyPointer(propName, prop);} 

  //------------  DEFAULT VOLUME -----------------------------

  //! Returns a reference to the volume
    virtual IVolume& defaultVolume()
       {return *m_defaultVolume;} 

 //! set properties of the default volume 
  virtual void addDefaultProperty(std::string propName, double prop)
     {m_defaultVolume->addProperty(propName, prop);} 
  virtual void addDefaultProperty(std::string propName, EVector& prop)
     {m_defaultVolume->addProperty(propName, prop);} 
  virtual void addDefaultProperty(std::string propName, EMatrix& prop)
     {m_defaultVolume->addProperty(propName, prop);} 
  virtual void addDefaultProperty(std::string propName, std::string prop)
     {m_defaultVolume->addProperty(propName, prop);} 

  virtual void addDefaultPropertyPointer(std::string propName, void* prop)
     {m_defaultVolume->addPropertyPointer(propName, prop);} 

   //! default main parameter
  virtual void setDefaultMainParameter(std::string name, 
                       std::string vectorName, 
                       int comp)
    {m_defaultVolume->setMainParameter(name, vectorName, comp);}



  //---------------- NAVIGATION LOGIC --------------------------------------


  //! add a logic to the list
  virtual void addLogic(std::string name, ILogic* p)
    {p->setName(name); m_logicMap[name]=p;}  
  //! add a logic to the list
  virtual void addLogic(std::string name){
    m_logicMap[name] = new LogicB();
    m_logicMap[name]->setName(name);
  }  

  //! Check that the logic exists
  virtual bool logicExists(std::string name){
    if (m_logicMap.count(name) != 0) return true;
    else return false;
  } 
  virtual bool logicExists(){
    if (m_logicName  != "") return true;
    else return false;
  } 

  //! load logic file 
  virtual bool loadLogic(std::string fileName);

  //! returns the logic name
  virtual std::string logicName() const {return m_logicName;}
  //! set the navigation logic by name
  virtual void setLogic(std::string name) {m_logicName=name;}

  //! adds a new object to the logic
  virtual void addObjectToLogic(std::string logicName, std::string objName, std::string type, int i, int j,  
                std::string inter, std::string noInter) 
    {if (checkLogic(logicName, objName, inter, noInter )) 
      logic(logicName).addLogicalObject(objName, type, i, j, inter, noInter);}

  virtual void addObjectToLogic(std::string objName, std::string type, int i, int j, 
                std::string inter, std::string noInter) 
    {if (checkLogic(m_logicName, objName, inter, noInter )) 
      logic().addLogicalObject(objName, type, i, j, inter, noInter);}

  //! returns a reference to the logic
  virtual ILogic& logic() {return *m_logicMap[m_logicName];}
  virtual ILogic& logic(std::string name) {return *m_logicMap[name];}

  //! returns a reference to the in volume logic providing the volume name
  virtual ILogic& logicInVolume(std::string volName){
    if (volName == "default") return logic();    
    else if (volumeExists(volName)) return volume(volName).logic();
  }
  //! checks everything when adding a volume to the Logic
  virtual bool checkLogic(std::string name, std::string vol, std::string inter,  std::string noInter);
  virtual bool checkLogic(std::string name, std::string vol);

  //! gets the vector with the names of the volumes in de logic
  virtual std::vector<std::string> nextVolumeVector(std::string thisVol, bool intersected, int sens, const IState& state);


  //! 
  virtual void setLogicalObjectName(std::string name) 
    {m_logicalObjectName = name;}
  
  virtual std::string logicalObjectName() const
    {return m_logicalObjectName;}
  

  //---------------- NAVIGATION LOGIC IN VOLUME--------------------------------------


  //! add a logic to the list
  virtual void addLogicInVolume(std::string volName, std::string name, ILogic* p)
    {volume(volName).addLogic(name, p);}  
  //! add a logic to the list
  virtual void addLogicInVolume(std::string volName, std::string name)
    {volume(volName).addLogic(name);}  

  //! returns the logic name
  virtual std::string logicNameInVolume(std::string volName)  
    {return volume(volName).logicName();}
  //! set the navigation logic by name
  virtual void setLogicInVolume(std::string volName, std::string name) 
    {volume(volName).setLogic(name);}


  //! add child volume to the logic of the father volume  
  virtual void addObjectToLogicInVolume(std::string logicName, std::string volName, std::string objName, 
                    std::string type, int i, int j, std::string inter, std::string noInter) 
    {volume(volName).addObjectToLogic(logicName, objName, type, i, j, inter, noInter);}


  virtual void addObjectToLogicInVolume(std::string volName, std::string objName, std::string type, int i, int j, 
                    std::string inter, std::string noInter) 
    {volume(volName).addObjectToLogic(objName, type, i, j, inter, noInter);}


  //------------  LOGIC FUNCTIONS -----------------------

  //! returns the logic function Map
  virtual const std::map<std::string, ILogicFunction*> logicFunctionMap() const {return m_logicFunctionMap;}

  //! add a logic Function
  virtual void addLogicFunction(std::string name, ILogicFunction* func)
    {m_logicFunctionMap[name] = func;}
  
  //! gives the LogicalObject provided the logicalObject name
  virtual ILogicFunction& logicFunction(std::string name) {return *m_logicFunctionMap[name];}
  
  
  //! Check if the logic function has been defined 
  virtual bool logicFunctionExists(std::string name) const{
    if (m_logicFunctionMap.count(name) != 0) return true;
    else return false;
  } 


  //------------  GENERAL -----------------------------
  
  //! returns the trajectory engine
  virtual TrajectoryEngine& engine() {return *m_engine;}

  //!  The name of the setup
  virtual void setName(std::string name) {m_name = name;}
  virtual std::string name() const {return m_name;}  

  //! set setup verbosity 
  virtual void setVerbosity(int v){m_verbosity = v;}
  //! return setup verbosity 
  virtual int verbosity() const {return m_verbosity;}  


  //! Print information about the setup
  virtual void info(int verb) const;
  virtual void info() const {info(1);}



 protected:  

  std::string m_name; 

  IVolume* m_defaultVolume;

  map<std::string, IVolume*> m_volumeMap;
  map<std::string, IVolume*> m_volumeDefMap;

  map<std::string, SurfaceServer*> m_surfServerMap;


  // Navigation logics
  std::string m_logicName;
  std::map<std::string, ILogic*> m_logicMap;

  // Logic functions  
  std::map<std::string, ILogicFunction*> m_logicFunctionMap;

  // The Trajectory Engine
  TrajectoryEngine* m_engine;

  int m_verbosity;

  std::string m_logicalObjectName;

};
#endif

---