calcul presque ok

Hacene SI HADJ MOHAND
1 parent 371c3b86
Showing 6 changed files with 219 additions and 27 deletions Show diff stats
src/ExternLib/Tsyganenko96/AMDAPlugin.cc
src/ExternLib/Tsyganenko96/GeopackWrapper.hh
src/ExternLib/Tsyganenko96/ProcessTiltAngle.cc
src/ExternLib/Tsyganenko96/ProcessTiltAngle.hh
src/ExternLib/Tsyganenko96/TiltAngleCreator.hh
src/ExternLib/Tsyganenko96/Tsyganenko96.hh
@@ -40,5 +40,13 @@ extern &quot;C&quot; void registerPlugin(AMDA::Plugins::PluginManager &amp; pm) {
     ProcessFactory factProcessTiltAngle= boost::factory<ProcessTiltAngle*>();
     ServicesServer::getInstance()->addProcessFactory("tilt_angle", factProcessTiltAngle);
     ServicesServer::getInstance()->linkProcessWithPlugin("tilt_angle", pm.getCurrentPluginPath());
+    
+       ProcessFactory factProcessAttitudeGSE = boost::factory<ProcessAttitudeGSE*>();
+    ServicesServer::getInstance()->addProcessFactory("attitude_gse", factProcessAttitudeGSE);
+    ServicesServer::getInstance()->linkProcessWithPlugin("attitude_gse", pm.getCurrentPluginPath());
+    
+       ProcessFactory factProcessAttitudeGSM = boost::factory<ProcessAttitudeGSM*>();
+    ServicesServer::getInstance()->addProcessFactory("attitude_gsm", factProcessAttitudeGSM);
+    ServicesServer::getInstance()->linkProcessWithPlugin("attitude_gsm", pm.getCurrentPluginPath());
  
 }
@@ -144,11 +144,37 @@ namespace AMDA {
                         lat *= (180. / M_PI);
                     }
  
-                    static void computeTiltAngle(int iyr, int iday, int ihour, int min, int isec, float & tiltAngle) {
-                                            float v_default_x = -400.0;
+                    static void computeTiltAngleAttitude(int iyr, int iday, int ihour, int min, int isec, float & tiltAngle, 
+                    std::vector<float> &attitudeGSE, std::vector<float> &attitudeGSM) {
+                   float v_default_x = -400.0;
                     float v_default_y = 0.0;
                     float v_default_z = 0.0;
-                        recalc_08_modified_(&iyr, &iday, &ihour, &min, &isec, &v_default_x, &v_default_y, &v_default_z, & tiltAngle);
+                    float XSM = 0.0;
+                    float YSM = 0.0;
+                    float ZSM = 1.0; 
+                    float XGSM = 0.0;
+                    float YGSM =0.0;
+                    float ZGSM = 0.0; 
+                    float XGSE = 0.0;
+                    float YGSE =0.0;
+                    float ZGSE = 0.0; 
+                    
+                    int transformFlag =1;
+                        recalc_08_(&iyr, &iday, &ihour, &min, &isec, &v_default_x, &v_default_y, &v_default_z);
+                        smgsw_08_(&XSM, &YSM, &ZSM,&XGSM, &YGSM, &ZGSM,&transformFlag); 
+                        gswgse_08_(&XGSM, &YGSM, &ZGSM,&XGSE, &YGSE, &ZGSE, &transformFlag);
+                        
+                        // tilte angle 
+                        tiltAngle = std::atan(XGSE/std::sqrt(YGSE*YGSE+ZGSE*ZGSE));
+                   //attitude in GSE
+                        attitudeGSE[0] = XGSE;
+                        attitudeGSE[1] = YGSE;
+                        attitudeGSE[2] = ZGSE;
+                           //attitude in GSM
+                        attitudeGSM[0] = XGSM;
+                        attitudeGSM[1] = YGSM;
+                        attitudeGSM[2] = ZGSM;
+                        
                     }
  
                 };
@@ -22,6 +22,8 @@
  
 namespace AMDA {
     namespace Parameters {
+        
+        // Tilte Angle
  
         ProcessTiltAngle::ProcessTiltAngle(Parameter &parameter) : SingleParamProcess_CRTP(parameter) {
         }
@@ -51,6 +53,68 @@ namespace AMDA {
  
             return time;
         }
+          // Attitude GSE
+        
+             ProcessAttitudeGSE ::ProcessAttitudeGSE(Parameter &parameter) : SingleParamProcess_CRTP(parameter) {
+        }
+
+        ProcessAttitudeGSE::ProcessAttitudeGSE(const ProcessAttitudeGSE& pProcess, Parameter &parameter) : SingleParamProcess_CRTP(pProcess, parameter) {
+        }
+
+        ProcessAttitudeGSE::~ProcessAttitudeGSE() {
+        }
+
+        TimeStamp ProcessAttitudeGSE::init() {
+
+            TimeStamp time = _parameterInput->init(this, _timeIntervalList);
+
+            Parameter::InfoList lInfoList = _parameterInput->getInfoList();
+            _parameter.getInfoList().insert(lInfoList.begin(), lInfoList.end());
+
+            _paramInput = _parameterInput->getParamData(this).get();
+            
+            TiltAngleCreator lCreator(*this, *_paramInput, "gse");
+
+            _operation = lCreator.getOperation();
+
+            _paramData = ParamDataSPtr(_operation->getParamOutput());
+
+            _paramData->setMinSampling(_paramInput->getMinSampling());
+
+            return time;
+        }
+        
+                 // Attitude GSM
+        
+             ProcessAttitudeGSM ::ProcessAttitudeGSM(Parameter &parameter) : SingleParamProcess_CRTP(parameter) {
+        }
+
+        ProcessAttitudeGSM::ProcessAttitudeGSM(const ProcessAttitudeGSM& pProcess, Parameter &parameter) : SingleParamProcess_CRTP(pProcess, parameter) {
+        }
+
+        ProcessAttitudeGSM::~ProcessAttitudeGSM() {
+        }
+
+        TimeStamp ProcessAttitudeGSM::init() {
+
+            TimeStamp time = _parameterInput->init(this, _timeIntervalList);
+
+            Parameter::InfoList lInfoList = _parameterInput->getInfoList();
+            _parameter.getInfoList().insert(lInfoList.begin(), lInfoList.end());
+
+            _paramInput = _parameterInput->getParamData(this).get();
+            
+            TiltAngleCreator lCreator(*this, *_paramInput, "gsm");
+
+            _operation = lCreator.getOperation();
+
+            _paramData = ParamDataSPtr(_operation->getParamOutput());
+
+            _paramData->setMinSampling(_paramInput->getMinSampling());
+
+            return time;
+        }
+        
  
     }
 }
@@ -33,6 +33,33 @@ namespace AMDA {
         private:
  
         };
+        
+       class ProcessAttitudeGSE : public SingleParamProcess_CRTP<ProcessAttitudeGSE> {
+        public:
+            ProcessAttitudeGSE (Parameter & parameter);
+            ProcessAttitudeGSE (const ProcessAttitudeGSE& pProcess, Parameter &pParameter);
+            virtual ~ProcessAttitudeGSE();
+
+            /**
+             * @overload Process::init()
+             */
+            virtual TimeStamp init();
+        private:
+
+        };
+        
+       class ProcessAttitudeGSM : public SingleParamProcess_CRTP<ProcessAttitudeGSM> {
+        public:
+            ProcessAttitudeGSM(Parameter & parameter);
+            ProcessAttitudeGSM(const ProcessAttitudeGSM& pProcess, Parameter &pParameter);
+            virtual ~ProcessAttitudeGSM();
+
+            /**
+             * @overload Process::init()
+             */
+            virtual TimeStamp init();
+        private:
+        };
     }
 }
  
@@ -162,14 +162,16 @@ namespace AMDA {
             Operation * getOperation() const {
                 return _operation;
             }
-
-
         private:
  
             template <typename Type>
             void createOperation() {
                 if (_type == "tilt")
                     _operation = new Tsyganenko96::DipoleTiltAngle<Type>(_process, dynamic_cast<ParamDataSpec<Type> &> (_paramData));
+                if (_type == "gse")
+                    _operation = new Tsyganenko96::DipoleAtitudeGSE<Type>(_process, dynamic_cast<ParamDataSpec<Type> &> (_paramData));
+                if (_type == "gsm")
+                    _operation = new Tsyganenko96::DipoleAtitudeGSM<Type>(_process, dynamic_cast<ParamDataSpec<Type> &> (_paramData));
             }
             Process &_process;
             ParamData &_paramData;
@@ -181,4 +183,3 @@ namespace AMDA {
 }
  
 #endif /* TILTANGLECREATOR_HH */
-
@@ -265,31 +265,69 @@ namespace AMDA {
                 bool _inGSE;
             };
  
-            template<typename DataType>
+            template<typename ElemType, class TOutputParamData>
             class DipoleBase : public Operation {
             public:
  
-                DipoleBase(Process& pProcess, ParamDataSpec<DataType>& paramInput) : Operation(pProcess),
+                DipoleBase(Process& pProcess, ParamDataSpec<ElemType>& paramInput) : Operation(pProcess),
                 _paramInput(paramInput),
-                _paramOutput(new ParamDataSpec<DataType>) {
+                _paramOutput(new TOutputParamData) {
                     _paramDataOutput = _paramOutput;
                 }
  
                 virtual ~DipoleBase() {
                 }
  
+                void write(ParamDataIndexInfo &pParamDataIndexInfo) {
+                    for (unsigned int _index = pParamDataIndexInfo._startIndex;
+                            _index < pParamDataIndexInfo._startIndex + pParamDataIndexInfo._nbDataToProcess;
+                            ++_index) {
+                        double crtTime = _paramInput.getTime(_index);
+                        time_t timestamp = crtTime;
+                        struct tm *tmp;
+                        tmp = gmtime(&timestamp);
+                        float tiltAngle;
+                        std::vector<float> attitudeGSE;
+                        attitudeGSE.resize(3);
+                        std::vector<float> attitudeGSM;
+                        attitudeGSM.resize(3);
+                        geopack::GeopackWrapper::computeTiltAngleAttitude(1900 + tmp->tm_year, 1 + tmp->tm_yday, tmp->tm_hour, tmp->tm_min, tmp->tm_sec,
+                                tiltAngle,
+                                attitudeGSE,
+                                attitudeGSM);
+                        ElemType tiltAngle_res = (ElemType) tiltAngle;
+                        std::vector<ElemType> attitudeGSE_res;
+                        attitudeGSE_res.resize(3);
+                        attitudeGSE_res[0] = (ElemType) attitudeGSE[0];
+                        attitudeGSE_res[1] = (ElemType) attitudeGSE[1];
+                        attitudeGSE_res[2] = (ElemType) attitudeGSE[2];
+
+                        std::vector<ElemType> attitudeGSM_res;
+                        attitudeGSM_res.resize(3);
+                        attitudeGSM_res[0] = (ElemType) attitudeGSM[0];
+                        attitudeGSM_res[1] = (ElemType) attitudeGSM[1];
+                        attitudeGSM_res[2] = (ElemType) attitudeGSM[2];
+
+                        attitudeGSM_res.resize(3);
+                        _paramOutput->pushTime(crtTime);
+                        pushData(tiltAngle_res, attitudeGSE_res, attitudeGSM_res);
+                    }
+                };
+                virtual void pushData(ElemType tilt, std::vector<ElemType> attitudeGSE, std::vector<ElemType> attitudeGSM) = 0;
+
+
             protected:
                 /**
                  * @brief Input paramter data.
                  */
-                ParamDataSpec<DataType>& _paramInput;
+                ParamDataSpec<ElemType>& _paramInput;
  
-                ParamDataSpec<DataType>* _paramOutput;
+                TOutputParamData* _paramOutput;
  
             };
  
             template <typename ElemType>
-            class DipoleTiltAngle : public DipoleBase<ElemType> {
+            class DipoleTiltAngle : public DipoleBase<ElemType, ParamDataSpec<ElemType>> {
             public:
  
                 /**
@@ -297,27 +335,55 @@ namespace AMDA {
                  * @details Create the ParamData type of the input ParamData.
                  */
                 DipoleTiltAngle(Process& pProcess, ParamDataSpec<ElemType >& paramInput)
-                : DipoleBase<ElemType>(pProcess, paramInput) {
+                : DipoleBase<ElemType , ParamDataSpec<ElemType> >(pProcess, paramInput) {
                 }
  
                 virtual ~DipoleTiltAngle() {
                 }
  
-                void write(ParamDataIndexInfo &pParamDataIndexInfo) {
-                    for (unsigned int _index = pParamDataIndexInfo._startIndex;
-                            _index < pParamDataIndexInfo._startIndex + pParamDataIndexInfo._nbDataToProcess;
-                            ++_index) {
-                        double crtTime = DipoleBase<ElemType>::_paramInput.getTime(_index);
-                        time_t timestamp = crtTime;
-                        struct tm *tmp;
-                        tmp = gmtime(&timestamp);
-                        float tiltAngle_res;
-                        geopack::GeopackWrapper::computeTiltAngle(1900 + tmp->tm_year, 1 + tmp->tm_yday, tmp->tm_hour, tmp->tm_min, tmp->tm_sec, tiltAngle_res);
+                void pushData(ElemType tilt, std::vector<ElemType> /*attitudeGSE*/, std::vector<ElemType> /*attitudeGSM*/) {
+                    DipoleBase<ElemType, ParamDataSpec<ElemType>>::_paramOutput->getDataList().push_back(tilt * 180.0 / (atan(1)*4));
+                }
+            };
+            
+           template <typename ElemType>
+            class DipoleAtitudeGSM : public DipoleBase<ElemType, ParamDataSpec<std::vector<ElemType>>> {
+            public:
  
-                        DipoleBase<ElemType>::_paramOutput->pushTime(crtTime);
-                        DipoleBase<ElemType>::_paramOutput->getDataList().push_back(tiltAngle_res*180.0/(atan(1)*4));
-                    }
-                };
+                /**
+                 * @brief Constructor.
+                 * @details Create the ParamData type of the input ParamData.
+                 */
+                DipoleAtitudeGSM(Process& pProcess, ParamDataSpec<ElemType >& paramInput)
+                : DipoleBase<ElemType, ParamDataSpec<std::vector<ElemType>>>(pProcess, paramInput) {
+                }
+
+                virtual ~DipoleAtitudeGSM() {
+                }
+
+                void pushData(ElemType /*tilt*/, std::vector<ElemType> /*attitudeGSE*/, std::vector<ElemType> attitudeGSM) {
+                    DipoleBase<ElemType, ParamDataSpec<std::vector<ElemType>>>::_paramOutput->getDataList().push_back(attitudeGSM);
+                }
+            };
+            
+                       template <typename ElemType>
+            class DipoleAtitudeGSE : public DipoleBase<ElemType, ParamDataSpec<std::vector<ElemType>>> {
+            public:
+
+                /**
+                 * @brief Constructor.
+                 * @details Create the ParamData type of the input ParamData.
+                 */
+                DipoleAtitudeGSE(Process& pProcess, ParamDataSpec<ElemType >& paramInput)
+                : DipoleBase<ElemType, ParamDataSpec<std::vector<ElemType>>>(pProcess, paramInput) {
+                }
+
+                virtual ~DipoleAtitudeGSE() {
+                }
+
+                void pushData(ElemType /*tilt*/, std::vector<ElemType> attitudeGSE, std::vector<ElemType> /*attitudeGSM*/) {
+                    DipoleBase<ElemType , ParamDataSpec<std::vector<ElemType>>>::_paramOutput->getDataList().push_back(attitudeGSE);
+                }
             };
  
         } /* namespace Tsyganenko96 */