Model.h

Go to the documentation of this file.

//   COCOA class header file
//Id:  Model.h
//CAT: Model
//
//   Utility class that steers the reading of the system description file
//              and contains the static data
//
//   History: v1.0
//   Pedro Arce
 
#ifndef MODEL_H
#define MODEL_H
 
#include <vector>
#include <map>
//#include <multimap.h>
 
#include "Alignment/CocoaUtilities/interface/CocoaGlobals.h"
class Entry;
//#include "Alignment/CocoaModel/interface/Entry.h"  //temporal
class OpticalObject;
//#include "Alignment/CocoaModel/interface/OpticalObject.h"
class Measurement;
class ALIFileIn;
class FittedEntriesReader;
 
class OpticalAlignments;
class OpticalAlignMeasurements;
 
#include "CondFormats/OptAlignObjects/interface/OpticalAlignInfo.h"
 
enum sectionType {
  sectGlobalOptions,
  sectParameters,
  sectSystemTreeDescription,
  sectSystemTreeData,
  sectMeasurements,
  sectReportOut
};
 
enum cocoaStatus {
  COCOA_Init,
  COCOA_ReadingModel,
  COCOA_InitFit,
  COCOA_FirstIterationInEvent,
  COCOA_NextIterationInEvent,
  COCOA_FitOK,
  COCOA_FitImproving,
  COCOA_FitCannotImprove,
  COCOA_FitChi2Worsened,
  COCOA_FitMatrixNonInversable
};
 
class Model {
public:
  //---------- Constructor / destructor
  Model();
  ~Model(){};
 
  static Model& getInstance();
 
  static cocoaStatus getCocoaStatus() { return theCocoaStatus; }
  static void setCocoaStatus(const cocoaStatus cs) { theCocoaStatus = cs; }
  static std::string printCocoaStatus(const cocoaStatus cs);
 
  static void readSystemDescription();
 
  //----------- Build OpticalObjects's from info in XML file
  void BuildSystemDescriptionFromOA(OpticalAlignments& optAlig);
  OpticalAlignInfo FindOptAlignInfoByType(const ALIstring& type);
  //----------- Build Measurements's from info in XML file
  void BuildMeasurementsFromOA(OpticalAlignMeasurements& measList);
 
 
  //  static std::map< ALIstring, ALIdouble, std::less<ALIstring> >& Parameters() {
  //     return theParameters;
  //  }
 
  static std::vector<std::vector<ALIstring> >& OptODictionary() { return theOptODictionary; }
 
  static std::vector<OpticalObject*>& OptOList() { return theOptOList; }
 
  static std::vector<Entry*>& EntryList() { return theEntryVector; }
 
  static std::vector<Measurement*>& MeasurementList() { return theMeasurementVector; }
 
  static Measurement* getMeasurementByName(const ALIstring& name, ALIbool exists = true);
 
  static ALIstring& SDFName() { return theSDFName; }
 
  static ALIstring& MeasFName() { return theMeasFName; }
 
  static ALIstring& ReportFName() { return theReportFName; }
 
  static ALIstring& MatricesFName() { return theMatricesFName; }
 
 
  static int getParameterValue(const ALIstring& sstr, ALIdouble& val);
 
  static OpticalObject* getOptOByName(const ALIstring& opto_name);
 
  static OpticalObject* getOptOByType(const ALIstring& type);
 
  static Entry* getEntryByName(const ALIstring& opto_name, const ALIstring& entry_name);
 
  static Entry* getEntryByName(const ALIstring& opto_entry_name) {
    ALIint slash_pos = opto_entry_name.rfind('/');
    ALIint length = opto_entry_name.length();
    ALIstring opto_name = opto_entry_name.substr(0, slash_pos);
    ALIstring entry_name = opto_entry_name.substr(slash_pos + 1, length);
    Entry* entry = getEntryByName(opto_name, entry_name);
    return entry;
  }
 
  static ALIbool getComponentOptOTypes(const ALIstring& opto_type, std::vector<ALIstring>& vcomponents);
 
  static ALIbool getComponentOptOs(const ALIstring& opto_name, std::vector<OpticalObject*>& vcomponents);
 
  static struct tm& MeasurementsTime() { return theMeasurementsTime; }
 
  static std::vector<OpticalAlignInfo> getOpticalAlignments() { return theOpticalAlignments; }
 
  static void addEntryToList(Entry* entry) {
    theEntryVector.push_back(entry);
    //-     std::cout << entry << entry->OptOCurrent()->name() << "ADDENTRY " << entry->name() << " " << EntryList().size() << std::endl;
  }
 
  static void addMeasurementToList(Measurement* measadd) {
    theMeasurementVector.push_back(measadd);
    //   std::cout << "ADD MEASUREMENT" << theMeasurementVector.size() << std::endl ;
  }
 
  //----- Set the name of the System Description File
  static void setSDFName(const ALIstring& name) { theSDFName = name; }
  //----- Set the name of the report File
  static void setReportFName(const ALIstring& name) { theReportFName = name; }
  //----- Set the name of the matrices File
  static void setMatricesFName(const ALIstring& name) { theMatricesFName = name; }
 
  static void setMeasurementsTime(struct tm& tim) { theMeasurementsTime = tim; }
 
  static ALIbool readMeasurementsFromFile(ALIstring only1Date = ALIstring(""), ALIstring only1Time = ALIstring(""));
 
private:
  static void reorderOptODictionary(const ALIstring& ssearch, std::vector<std::vector<ALIstring> >& OptODictionary2);
 
  //  static void readMeasurements( ALIFileIn& filein );
 
  static void buildMeasurementsLinksToOptOs();
 
  static void SetValueDisplacementsFromReportOut();
 
  static Model* theInstance;
 
  //-  static std::map< ALIstring, ALIdouble, std::less<ALIstring> > theParameters;
 
  static std::vector<std::vector<ALIstring> > theOptODictionary;
 
  //-  static multimap< ALIstring, OpticalObject*, std::less<ALIstring> > theOptOtree;
  //  static map< ALIstring, OpticalObject*, std::less<ALIstring> > theOptOList;
  static std::vector<OpticalObject*> theOptOList;
 
  static std::vector<Entry*> theEntryVector;
 
  static std::vector<Measurement*> theMeasurementVector;
 
  static ALIstring theSDFName;
  static ALIstring theMeasFName;
  static ALIstring theReportFName;
  static ALIstring theMatricesFName;
 
public:
  //----- Steers the storing of the components of OptO named 'optoname'
  static ALIbool createCopyComponentList(const ALIstring& optoname);
  //----- Get next object to copy from the stored list of components and copy it
  static OpticalObject* nextOptOToCopy();
 
private:
  //----- Stores the components of opto
  static ALIbool fillCopyComponentList(const OpticalObject* opto);
  //----- List of components of an OptO to copy
  static std::vector<OpticalObject*> theOptOsToCopyList;
  //----- Iterator of the list of components of an OptO to copy
  static std::vector<OpticalObject*>::const_iterator theOptOsToCopyListIterator;
 
public:
  static ALIint Ncmslinkrange;
  static std::vector<ALIdouble> CMSLinkRangeDetValue;
 
public:
  void CMSLinkFit(ALIint cmslink);
 
private:
  void CMSLinkCleanModel();
  static void CMSLinkDeleteOptOs();
  static void CMSLinkSaveParamFittedSigma(ALIint cmslink);
  static void CMSLinkSaveParamFittedValueDisplacement(ALIint cmslink);
  static void CMSLinkRecoverParamFittedSigma(ALIint cmslink);
  static void CMSLinkRecoverParamFittedValueDisplacement(ALIint cmslink);
 
  static ALIint CMSLinkIteration;
 
  //----- METHODS FOR FITTING IN SEVERAL STEPS
  static void deleteOptO(const ALIstring& opto_name);
  static void deleteOptO(OpticalObject* opto);
 
  static void saveParamFittedSigma(const ALIstring& opto_name, const ALIstring& entry_name);
 
  static void saveParamFittedCorrelation(const ALIstring& opto_name1,
                                         const ALIstring& entry_name1,
                                         const ALIstring& opto_name2,
                                         const ALIstring& entry_name2);
 
  static void recoverParamFittedSigma(const ALIstring& opto_name, const ALIstring& entry_name, const ALIuint position);
 
public:
  static ALIdouble getParamFittedSigmaVectorItem(const ALIuint position);
  static FittedEntriesReader* getFittedEntriesReader() { return theFittedEntriesReader; }
 
private:
  static void cleanParamFittedSigmaVector() {
    ALIuint pfsv_size = theParamFittedSigmaVector.size();
    for (ALIuint ii = 0; ii < pfsv_size; ii++) {
      theParamFittedSigmaVector.pop_back();
    }
  }
 
  static void cleanParamFittedValueDisplacementMap() {
    theParamFittedValueDisplacementMap.erase(theParamFittedValueDisplacementMap.begin(),
                                             theParamFittedValueDisplacementMap.end());
  }
 
  static void copyMeasurements(const std::vector<ALIstring>& wl);
 
private:
  static cocoaStatus theCocoaStatus;
 
  static std::vector<ALIdouble> theParamFittedSigmaVector;
 
  static std::map<ALIstring, ALIdouble, std::less<ALIstring> > theParamFittedValueDisplacementMap;
 
  static struct tm theMeasurementsTime;
 
  static FittedEntriesReader* theFittedEntriesReader;
 
  static std::vector<OpticalAlignInfo> theOpticalAlignments;
};
 
#endif