OpticalObject.h

Go to the documentation of this file.

//   COCOA class header file
//Id:  OpticalObject.h
//CAT: Model
//
//   Base class to describe all types of Optical Objects 
// 
//   History: v1.0 
//   Pedro Arce

#ifndef _OPTICALOBJECT_HH
#define _OPTICALOBJECT_HH

#include "Alignment/CocoaUtilities/interface/CocoaGlobals.h"
#include <cstdint>

class LightRay;
class Measurement;
class Entry;
class ALIFileIn;
class Measurement;
class ALIPlane;

class CocoaMaterialElementary;
class CocoaSolidShape;

#include "CLHEP/Vector/ThreeVector.h"
#include "CLHEP/Vector/Rotation.h"
#include <fstream>
#include <vector>
class OpticalAlignInfo;
class OpticalAlignParam;

enum XYZcoor{XCoor, YCoor, ZCoor};

class OpticalObject
{
  friend std::ostream& operator << (std::ostream& os, const OpticalObject& c);

 public:
  //---------- Constructors / destructor
  OpticalObject(){ };
  OpticalObject(OpticalObject* parent, const ALIstring& type, const ALIstring& name, const ALIbool copy_data);
  virtual ~OpticalObject();

  //----- Steering function to read OptO data from SDF file (and also start component OptOs)
  void construct(); 

  void constructFromOptAligInfo( const OpticalAlignInfo& oaInfo );
  std::vector<ALIstring> getCoordinateFromOptAlignParam( const OpticalAlignParam& oaParam );
  void createComponentOptOsFromOptAlignInfo();

  virtual void constructMaterial(); 
  virtual void constructSolidShape(); 

  virtual void fillVRML(){ } ;
  virtual void fillIguana(){ };


 // ACCESS DATA MEMBERS
  const ALIstring& name() const{ return theName; };
  const ALIstring& type() const{ return theType; };
  const OpticalObject* parent() const{ return theParent;};

  // Return List of Coordinate Entries
  const std::vector< Entry* >& CoordinateEntryList() const {
     return theCoordinateEntryVector;
  }
  // Return List of Extra Entries
  const std::vector< Entry* >& ExtraEntryList() const {
    return theExtraEntryVector;
  }
  // Return List of Extra Entry Values
  std::vector< ALIdouble >& ExtraEntryValueList() {
    return theExtraEntryValueVector;
  }

  const std::vector< ALIdouble >& ExtraEntryValueOriginalList() {
    return theExtraEntryValueOriginalVector;
  }
  const std::vector< ALIdouble >& ExtraEntryValueOriginalOriginalList() {
    return theExtraEntryValueOriginalOriginalVector;
  }

 // ACCESS CENTRE AND ROTATION DATA MEMBERS
  const CLHEP::Hep3Vector& centreGlob() const {
    return theCentreGlob;
  }

  const CLHEP::Hep3Vector& centreGlobal() const {
    return centreGlob();
  }

  const CLHEP::Hep3Vector centreLocal() const;

  const CLHEP::Hep3Vector& centreGlobOriginal() const {
    return theCentreGlobOriginal;
  }
  const CLHEP::Hep3Vector& centreGlobOriginalOriginal() const {
    return theCentreGlobOriginalOriginal;
  }
  const CLHEP::HepRotation& rmGlob() const {
    return theRmGlob;
  }

  const CLHEP::HepRotation rmLocal() const;

  const CLHEP::HepRotation& rmGlobOriginal() const {
    return theRmGlobOriginal;
  }
  const CLHEP::HepRotation& rmGlobOriginalOriginal() const {
    return theRmGlobOriginalOriginal;
  }


  const double getEntryCentre( const XYZcoor coor ) const;
  const double getEntryCentre( const ALIstring& coor ) const;

  const double getEntryRMangle( const XYZcoor coor ) const;
  const double getEntryRMangle( const ALIstring& coor ) const;

  const ALIuint ID() const { return theCmsswID; }
  const ALIuint getCmsswID() const { return theCmsswID; }
  void setCmsswID( ALIuint id ){ theCmsswID = id; }
  void setID( ALIuint id ) { theCmsswID = id; }

  // SET DATA METHODS
  void setRmGlobalOriginal( const CLHEP::HepRotation& rm ){
    theRmGlobOriginal = rm; 
  }
  void setGlobalRMOriginalOriginal(const CLHEP::HepRotation& rmoriori );
  void propagateGlobalRMOriginalOriginalChangeToChildren( const CLHEP::HepRotation& rmorioriold, const CLHEP::HepRotation& rmoriorinew );
   CLHEP::HepRotation buildRmFromEntryValuesOriginalOriginal();

  void setRmGlobal( const CLHEP::HepRotation& rm ){
    theRmGlob = rm; 
  }

  void setType( const ALIstring& type ) {
   theType = type; 
  }
  void addCoordinateEntryToList( Entry* entry ) {
     theCoordinateEntryVector.push_back( entry );
  }
  void addExtraEntryToList( Entry* entry ) {
     theExtraEntryVector.push_back( entry );
  }
  void addExtraEntryValueToList( ALIdouble entry_value ) {
     theExtraEntryValueVector.push_back( entry_value );
  }
  void addExtraEntryValueOriginalToList( ALIdouble entry_value ) {
     theExtraEntryValueOriginalVector.push_back( entry_value );
  }
  void addExtraEntryValueOriginalOriginalToList( ALIdouble entry_value ) {
     theExtraEntryValueOriginalOriginalVector.push_back( entry_value );
  }


  //-  void test(){};
  //@@@@@----- METHODS USED IN Fit
  //---------- Propagate the light ray with the behaviour 'behav'
  virtual void participateInMeasurement( LightRay& lightray, Measurement& meas, const ALIstring& behav );
  //---------- default behaviour (depends of subclass type). A default behaviour can be makeMeasurement(), therefore you have to pass 'meas'
  virtual void defaultBehaviour( LightRay& lightray, Measurement& meas );
  //---------- Fast simulation of deviation of the light ray (reflection, shift, ...)
  virtual void fastDeviatesLightRay( LightRay& lightray );
  //---------- Detailed simulation of the light ray traversing
  virtual void fastTraversesLightRay( LightRay& lightray );
  //---------- Detailed simulation of deviation of the light ray (reflection, shift, ...)
  virtual void detailedDeviatesLightRay( LightRay& lightray );
  //---------- Fast simulation of the light ray traversing
  virtual void detailedTraversesLightRay( LightRay& lightray );

  //---------- Fast simulation of the light ray traversing
  virtual void makeMeasurement( LightRay& lightray, Measurement& meas );

  //---------- User Defined Behaviour
  virtual void userDefinedBehaviour( LightRay& lightray, Measurement& meas, const ALIstring& behav);

  //---------- Obtain the Z Axis of the OptO (ZAxis rotated with the OptO rotation matrix)
  CLHEP::Hep3Vector getZAxis() {
    CLHEP::Hep3Vector ZAxis(0.,0.,1.);
    CLHEP::HepRotation rmt = rmGlob();
    ZAxis = rmt*ZAxis;
    return ZAxis;
  }
  //---------- Get one of the plates of an OptO made of two parallel plates
  ALIPlane getPlate(const ALIbool forwardPlate, const ALIbool applyWedge);

  //---------- Displacements to get the derivative of a measurement w.r.t an entry
  //----- Displace the centre coordinate 'coor'
  void displaceCentreGlob( const XYZcoor coor, const  ALIdouble disp);
  CLHEP::Hep3Vector getDisplacementInLocalCoordinates( const XYZcoor coor, const ALIdouble disp );
   void displaceCentreGlob( const CLHEP::Hep3Vector& dispVec);
  //----- Rotate around axis 'coor' 
  void displaceRmGlobAroundGlobal(OpticalObject* opto1stRotated, const XYZcoor coor, const ALIdouble disp);
  void displaceRmGlobAroundLocal(OpticalObject* opto1stRotated, const XYZcoor coor, const ALIdouble disp);
  //----- Displace extra entry number 'entryNo' 
  void displaceExtraEntry( const ALIuint entryNo, const ALIdouble disp);
  void setExtraEntryValue(const ALIuint entryNo, const ALIdouble disp);

  //----------- Displacements of original coordinates: do it to reset the original data 
  //----------- every new iteration of the non linear fit
  //----- Displace the centre coordinate 'coor'
  void displaceCentreGlobOriginal( const XYZcoor coor, const ALIdouble disp);
  void displaceCentreGlobOriginal( const CLHEP::Hep3Vector& dispVec);
  void displaceCentreGlobOriginalOriginal( const XYZcoor coor, const ALIdouble disp);
  void displaceCentreGlobOriginalOriginal( const CLHEP::Hep3Vector& dispVec);
  //----- Rotate around axis 'coor' 
  void displaceRmGlobOriginal( const OpticalObject* opto1stRotated, const XYZcoor coor, const ALIdouble disp);
  void displaceRmGlobOriginalOriginal( const OpticalObject* opto1stRotated, const XYZcoor coor, const ALIdouble disp);
  //----- Displace extra entry number 'entryNo' 
  void displaceExtraEntryOriginal( const ALIuint entryNo, const ALIdouble disp);
  void displaceExtraEntryOriginalOriginal( const ALIuint entryNo, const ALIdouble disp);

  //---------- Reset the global coordinates and extra entries (after derivative is finished)
  void resetGlobalCoordinates();
  void resetOriginalOriginalCoordinates();

  // Find position of an extra entry in ExtraEntryList (and therefore in ExtraEntryValueList)
  const ALIint extraEntryNo( const ALIstring& entry_name ) const;

  // //@@ Find an extra Entry by name and return its value. If entry not found, stop.
  const ALIdouble findExtraEntryValueMustExist( const ALIstring& eename ) const;  
  // Find an extra Entry by name and return its value, if it is not found return 0
  const ALIdouble findExtraEntryValue( const ALIstring& eename ) const;  

  // Find an extra Entry by name and pass its value. Return if entry is found or not
  const ALIbool findExtraEntryValueIfExists( const ALIstring& eename, ALIdouble& value ) const;

  // Return the name of the OptO without its path
  const ALIstring shortName() const;
  // Return the name of the OptO with its path
  const ALIstring longName() const{ 
    return name();
  }

  void setMeas( Measurement* meas ) {
    theCurrentMeas = meas;
  }
  Measurement* meas() {
    return theCurrentMeas;
  }

  std::vector<double> getRotationAnglesInOptOFrame( const OpticalObject* optoAncestor, const std::vector< Entry* >& entries ) const;
  std::vector<double> getLocalRotationAngles(  const std::vector< Entry* >& entries ) const;
  std::vector<double> getRotationAnglesFromMatrix( CLHEP::HepRotation& rmLocal, const std::vector< Entry* >& entries ) const;
  double diff2pi( double ang1, double ang2 );
  bool eq2ang( double ang1, double ang2 );
  double approxTo0( double val );
  double addPii( double val );
  int checkMatrixEquations( double angleX, double angleY, double angleZ, CLHEP::HepRotation* rot = 0);

  //-  CLHEP::Hep3Vector GetAxisForDisplacement( const XYZcoor coor );
  void setGlobalCoordinates();
  void setOriginalEntryValues();

 CocoaMaterialElementary* getMaterial() const {
   return theMaterial; }
 CocoaSolidShape* getSolidShape() const {
   return theSolidShape; }

  //private DATA METHODS
private:
  // Reads the data 
  void readData( ALIFileIn& filein );
  // Copy the data from last OptO found of the same type
  void copyData();

  // Read extra entries
  void readExtraEntries( ALIFileIn& filein );

 protected:
  // Create and fill an extra entry
  virtual void fillExtraEntry( std::vector<ALIstring>& wordlist );
 private:
  // Read centre or angles
  void readCoordinates( const ALIstring& coor_type_read, const ALIstring& coor_type_expected, ALIFileIn& filein );
  // Create and fill a coordinate entry
  void fillCoordinateEntry( const ALIstring& coor_name, const std::vector<ALIstring>& wordlist );
  // Set angles null
  void setAnglesNull();

  //------ Build wordlist copying data of entry 'entry'
  void buildWordList( const Entry* entry, std::vector<ALIstring>& wordlist );

  // start Optical Objects that are components of current 
  void createComponentOptOs( ALIFileIn& filein );

  OpticalObject* createNewOptO( OpticalObject* parent, ALIstring optoType, ALIstring optoName, ALIbool fcopyComponents );

  // Set global centre and rotation matrix
  void setGlobalCentre();
  void setGlobalRM();
  void setGlobalCoordinatesOfComponents();

  void SetCentreLocalFromEntryValues();
  void SetCentreGlobFromCentreLocal();
  void SetRMLocalFromEntryValues();
  void SetRMGlobFromRMLocal();
  void SetRMGlobFromRMLocalOriginalOriginal( const CLHEP::HepRotation& rmoriori );
  // Calculate local rot axis with new rm glob
  void calculateLocalRotationAxisInGlobal();

  void transformCylindrical2Cartesian();
  void transformSpherical2Cartesian();
  void transformGlobal2Local();

template<class T>
  void rotateItAroundGlobal( T& object, const XYZcoor coor, const double disp );

 CLHEP::Hep3Vector getDispVec( const XYZcoor coor, const ALIdouble disp);

 void SetCentreIsGlobal( ALIbool isG ) {
   centreIsGlobal = isG; }
 void SetAnglesIsGlobal( ALIbool isG ) {
   anglesIsGlobal = isG; }

private:
  // private DATA MEMBERS 
  OpticalObject* theParent;
  ALIstring theType;
  ALIstring theName;  
  //----- Boolean to mark if data is going to be read or copied from closest previous OptO with same type
  ALIbool fcopyData;

  //----- Global centre and rotation matrix
  CLHEP::Hep3Vector theCentreGlob;
  CLHEP::HepRotation theRmGlob;
  //----- Original global centre and rotation matrix (for backup when they are changed to get derivatives)
  CLHEP::Hep3Vector theCentreGlobOriginal;
  CLHEP::HepRotation theRmGlobOriginal;
  CLHEP::Hep3Vector theCentreGlobOriginalOriginal;
  CLHEP::HepRotation theRmGlobOriginalOriginal;

  // Lists of entries
  std::vector< Entry* > theCoordinateEntryVector;
  std::vector< Entry* > theExtraEntryVector;

  // Lists of values of entries
  std::vector< ALIdouble > theExtraEntryValueVector;
  std::vector< ALIdouble > theExtraEntryValueOriginalVector;
  std::vector< ALIdouble > theExtraEntryValueOriginalOriginalVector;

  // centre and angles are global
  ALIbool centreIsGlobal;
  ALIbool anglesIsGlobal;

  Measurement* theCurrentMeas;

  CLHEP::Hep3Vector axisXLocalInGlobal;
  CLHEP::Hep3Vector axisYLocalInGlobal;
  CLHEP::Hep3Vector axisZLocalInGlobal;

  ALIuint theCmsswID;

 protected:
  CocoaMaterialElementary* theMaterial;
  CocoaSolidShape* theSolidShape;

  ALIint verbose;
};

#endif