Measurement.h

Go to the documentation of this file.

// COCOA class header file
// Id:  Measurement.h
// CAT: Model
//
// Class for measurements
// 
// History: v1.0.0
// v1.1.0: add measurementsFileName
// 
// Authors:
//   Pedro Arce

#ifndef _MEASUREMENT_HH
#define _MEASUREMENT_HH

#include <vector>
#include <cstdlib>

#include "Alignment/CocoaUtilities/interface/CocoaGlobals.h"
#include "Alignment/CocoaUtilities/interface/ALIUtils.h"
class OpticalObject;
class Entry;
class EntryLength;
class OpticalAlignMeasurementInfo;
class OpticalAlignParam;

class Measurement
{ 
public:
  //----- Constructors / destructor
  Measurement( const ALIint measdim, ALIstring& type, ALIstring& name );
  Measurement(){ };   
  virtual ~Measurement();
    
  // construct Measurement reading date from file
  void construct();
  void postConstruct();
  // Fill the list of names of OptOs that take part in this measurement ( names only )
  virtual void buildOptONamesList( const std::vector<ALIstring>& wl );
  // Fill the data 
  void fillData(ALIuint coor, const std::vector<ALIstring>& wl );
  void fillData( ALIuint coor, OpticalAlignParam* oaParam);

  // Convert OptOs names in OptOs pointers
  void buildOptOList();
  // Make list including every entry of every ancestor of each Measured OptO
  void buildAffectingEntryList();
  void addAffectingEntriesFromOptO( const OpticalObject* optoP );

  // Get simulated value (called every time a parameter is displaced)
  virtual void calculateSimulatedValue( ALIbool firstTime ) {};
  // Get simulated value original (called every time a parameter value is changed: after getting values from file and every non-linear fit iteration )
  void calculateOriginalSimulatedValue();

  // Dump the list of OptO names (used mainly when checking their order)
  void DumpBadOrderOptOs();

  // Calculate derivative of this Measurement with respect to a parameter of an Entry
  std::vector<ALIdouble> DerivativeRespectEntry( Entry* entry );

  // get the ':X' that determines how the behaviour of the OptO w.r.t. this Measurement
  ALIstring getMeasuringBehaviour( const std::vector< OpticalObject* >::const_iterator vocite);

 // Get the previous OptOs in the list of OptO that take part in this measurement
  const OpticalObject* getPreviousOptO( const OpticalObject* Popto ) const;
  //---------- Add any correction between the measurement data and the default format in COCOA
  virtual void correctValueAndSigma(){};

  //---------- Convert from V to rad
  virtual void setConversionFactor( const std::vector<ALIstring>& wordlist ){
    std::cerr << " Measurement::setConversionFactor should never be called " << std::endl;
    exit(1); };

  static void setCurrentDate( const std::vector<ALIstring>& wl );

  void copyMeas( Measurement* meas, const std::string& subsstr1, const std::string& subsstr2 );

  void constructFromOA( OpticalAlignMeasurementInfo&  measInfo);

 // ACCESS DATA MEMBERS
  const ALIuint dim() const { 
    return theDim;
  }
 
  const ALIstring& type() const {
    return theType;
  }
  
  const ALIstring& name() const {
    return theName;
  }

  const ALIstring& sensorName() {
    ALIstring sensName = theName;
    ALIint colon = theName.find(':');
    theName = theName.substr(colon+1, theName.length()-colon);
    return theName;
  }
  
  //  const OpticalObject* OptOCurrent() const {
  //  return _OptOCurrent;
  // }
  
  const std::vector<ALIstring>& OptONameList() const {
    return _OptONameList;
  }
  
  std::vector<OpticalObject*>& OptOList() {
    return _OptOList;
  }
  
  const std::vector<Entry*>& affectingEntryList() const {
    return theAffectingEntryList;
  }
  
  const  ALIdouble valueSimulated( ALIuint ii ) const {
    return theValueSimulated[ii];
  }

  const ALIdouble valueSimulated_orig( ALIuint ii ) const {
    return theValueSimulated_orig[ii];
  }

  const ALIdouble* value() const {
    return theValue;
  } 
  const ALIdouble value( ALIuint ii ) const {
    return theValue[ii];
  } 

  const ALIdouble* sigma() const {
    return theSigma;
  } 

  const ALIdouble sigma( ALIuint ii) const {
    return theSigma[ii];
  } 

  const ALIstring valueType( ALIuint ii) const {
    return theValueType[ii];
  } 

  virtual const ALIdouble valueDimensionFactor() const{
    return ALIUtils::LengthValueDimensionFactor();
  }

  virtual const ALIdouble sigmaDimensionFactor() const{
    return ALIUtils::LengthSigmaDimensionFactor();
  }

  static ALIstring getCurrentDate(){
    return theCurrentDate;
  }
  static ALIstring getCurrentTime(){
    return theCurrentTime;
  }

  const CLHEP::Hep3Vector& getLightRayPosition( ) const{
    return theLightRayPosition; 
  }
  const CLHEP::Hep3Vector& getLightRayDirection( ) const{ 
    return theLightRayDirection; 
  }

 // SET DATA MEMBERS
  void setValue( ALIint coor, ALIdouble val) {
    theValue[coor] = val;
  }
  
  void setSigma( ALIint coor, ALIdouble val) {
    theSigma[coor] = val;
    //-    std::cout << coor << " setting sigma " << theSigma[coor] << std::endl;
  }

  void setType( ALIstring type ) {
    theType = type;
  }

  void SetDimension(ALIuint dim) {
    theDim = dim;
  }    

  void AddOptONameListItem(ALIstring optos) {
      _OptONameList.push_back( optos );
  }

  void AddOptOListItem(OpticalObject* opto) {
      _OptOList.push_back( opto );
  }

  void setValueSimulated_orig( ALIint coor, ALIdouble value) {
      theValueSimulated_orig[coor] = value;
  }

  void setValueSimulated( ALIint coor, ALIdouble value) {
      theValueSimulated[coor] = value;
  }
  virtual int xlaserLine( ALIuint ii) { std::cerr << "!!!! Measurement::xlaserLine is not returning anything " << std::endl; abort(); };
 
  //----- Set name as type plus name of last OptO 
  void setName();

  // Check is value is simulated
  bool valueIsSimulated(ALIint coor) {
      return theValueIsSimulated[coor];
  }

  virtual void setXlaserLine( ALIuint ii, int val ) { };

 static ALIdouble cameraScaleFactor;

 static ALIstring& measurementsFileName() { 
   return theMeasurementsFileName;
 }
 static void setMeasurementsFileName( const ALIstring& filename ) { 
   //-   std::cout << " setting file name " << filename << std::endl;
   theMeasurementsFileName = filename;
   //-   std::cout << " dsetting file name " << filename << std::endl;
 }

 void setLightRayPosition( const CLHEP::Hep3Vector& lightRayPosition )
   { theLightRayPosition = lightRayPosition; }
 void setLightRayDirection( const CLHEP::Hep3Vector& lightRayDirection )
   { theLightRayDirection = lightRayDirection; }

 protected:  
  // Substitute '..' by parent OptO in name 
  void Substitute2p( ALIstring& ref, const ALIstring& firstref, int NtwoPoints);
  void printStartCalculateSimulatedValue( const Measurement* meas);


 // private DATA MEMBERS
private:
  ALIuint theDim;
  ALIstring theType;
  ALIdouble* theValue;  
  ALIdouble* theSigma;
  ALIstring theName;  //name of last OptO
  ALIstring* theValueType;  //type of each measurement value (e.g. H:, TA:)

  //----- values of measurement obtained simulating the light ray through all the OptO that take part in the measurement
  ALIdouble* theValueSimulated;
  //----- values of measurement obtained simulating the light ray through all the OptO that take part in the measurement, for original values of every entry
  ALIdouble* theValueSimulated_orig;

  //-  ALIdouble* theSigmaErrorPropagation;
  //-  ALIdouble* theSigmaRegression;

  //----- Boolean to indicate if theValueSimulated_orig is set equal to the simulated values with original entries
  ALIbool* theValueIsSimulated;

  //----- List of OptOs that take part in this measurement ( names only )
  std::vector<ALIstring> _OptONameList;
  //----- List of OptOs that take part in this measurement ( pointers )
  std::vector<OpticalObject*> _OptOList;
  //----- List of OptOs Measured and their ancestors
  std::vector<Entry*> theAffectingEntryList;

  CLHEP::Hep3Vector theLightRayPosition;
  CLHEP::Hep3Vector theLightRayDirection;
  static ALIstring theMeasurementsFileName;

  static ALIstring theCurrentDate;  
  static ALIstring theCurrentTime;  
 public:
  static ALIbool only1;
  static ALIstring only1Date;
  static ALIstring only1Time;

};

#endif