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