Changeset 1148 in Sophya


Ignore:
Timestamp:
Aug 29, 2000, 12:03:24 PM (25 years ago)
Author:
ansari
Message:

mise a jour

Location:
trunk/SigPredictor
Files:
31 edited

Legend:

Unmodified
Added
Removed

  • trunk/SigPredictor/AutresASiGPred.cc

    r798 r1148  
    2121#include "sigcalctools.h"
    2222#include "allfilter.h"
    23 #include "fitsioserver.h"
    2423
    2524int MakeGalaxyMap(double Resolution);   // Resolution en degres
    … …  
    2928// On passe aux cartes de fonds physiques
    3029// Initialisations
    31    FitsIoServer FitsServer;
    3230   char filename[150]="";
    3331     
    … …  
    7674                }       
    7775        }
    78        
    79 
    80 
    8176        return 0;
    8277}

  • trunk/SigPredictor/Lightsource_test.cc

    r798 r1148  
    88
    99#ifdef __MWERKS__
    10    #include "mwerksmath.h"
    1110   #include "unixmac.h"
    1211   #include "macenvvariables.h"
    … …  
    3736        // Basictests();
    3837       
    39         //char FilePointes[32]="bolopoin.ascii";
    40         //MakeArcheopsTimelines(FilePointes);
     38        char FilePointes[32]="bolopoin.ascii";
     39        MakeArcheopsTimelines(FilePointes);
    4140       
    42         MakeGalaxyMap(1./6);
     41        //      MakeGalaxyMap(1./6);
    4342       
    4443        return 0;

  • trunk/SigPredictor/TestSources.cc

    r798 r1148  
    99
    1010#ifdef __MWERKS__
    11    #include "mwerksmath.h"
    1211   #include "unixmac.h"
    1312   #include "macenvvariables.h"
    … …  
    1514
    1615#include "squarefilt.h"
    17 #include "fitsioserver.h"
    1816
    1917#include "alllobe.h"
    … …  
    2321#define NLatTestMap (256)
    2422
    25 static FitsIoServer FitsServer;
    2623int CompareMapResults();
    2724int TestSommeMapsInBand(char file1[], long nlat);
    … …  
    5653        char filename[150];
    5754         // On lit les donnees brutes
    58     SphereGorski<float> PowerMap(nlat);         // Pour se mettre a l'unite nW/m2/St
     55    SphereHEALPix<r_4> PowerMap(nlat);  // Pour se mettre a l'unite nW/m2/St
    5956   
    6057    // Definition channel C
    … …  
    8683 
    8784    // On ajoute du bruit
    88     {   SphereGorski<float> NoiseChanCMap(nlat);
     85    {   SphereHEALPix<r_4> NoiseChanCMap(nlat);
    8986        sprintf(filename, "%schannelC_noise_res%04i.fits",PATHSTangoRes,nlat);
    9087        FitsServer.load(NoiseChanCMap,filename);
    … …  
    104101    // Test-Validation Ptotale si ca se passe bien
    105102        {       
    106                 SphereGorski<float> ObsTotSTango(256);
     103                SphereHEALPix<r_4> ObsTotSTango(256);
    107104            sprintf(filename, "%schannelC_obs_res0256.fits",PATHSTangoRes);
    108105            FitsServer.load(ObsTotSTango,filename);
    … …  
    143140               
    144141                        // La carte
    145                 SphereGorski<float> ChannelCConvolue(nlat);
     142                SphereHEALPix<r_4> ChannelCConvolue(nlat);
    146143               
    147144                        // On convolue
    … …  
    167164  char* PATHSTangoRes=getenv("PATHSTangoRes");
    168165#endif
    169                 SphereGorski<float> ObsConvolSTango(nlat);
     166                SphereHEALPix<r_4> ObsConvolSTango(nlat);
    170167            sprintf(filename, "%schannelC_convolved.fits",PATHSTangoRes);
    171168            FitsServer.load(ObsConvolSTango,filename);
    … …  
    183180            cout<<" Moy="<<Moy<<" sigma="<<sigma<<endl<<endl;       
    184181                   
    185             SphereGorski<float> ChannelCConvolue(nlat);
     182            SphereHEALPix<r_4> ChannelCConvolue(nlat);
    186183            sprintf(filename,"ChannelConvolue%04i.fits",nlat);
    187184            FitsServer.load(ChannelCConvolue,filename);
    … …  
    234231 /*
    235232  // Test Module synchrotron
    236     SphereGorski<float> ChanCSynchro(256);
    237     SphereGorski<float> MYCSynchro(256);
     233    SphereHEALPix<r_4> ChanCSynchro(256);
     234    SphereHEALPix<r_4> MYCSynchro(256);
    238235   
    239236   
    … …  
    279276/*
    280277      // Test Module CMB
    281     SphereGorski<float> ChanCCMB(256);
    282     SphereGorski<float> MYCCMB(256);
     278    SphereHEALPix<r_4> ChanCCMB(256);
     279    SphereHEALPix<r_4> MYCCMB(256);
    283280               
    284281  // Sans lobes d'abord: Integrale sur les dependances spectrales
    … …  
    322319   
    323320      // Test Module poussire diffuse
    324     SphereGorski<float> ChanCDiffDust(256);
    325     SphereGorski<float> MYCDiffDust(256);
     321    SphereHEALPix<r_4> ChanCDiffDust(256);
     322    SphereHEALPix<r_4> MYCDiffDust(256);
    326323   
    327324   
    … …  
    364361
    365362 
    366   SphereGorski<float>* pTestMap;
    367   pTestMap= new SphereGorski<float>(64);
    368   SphereGorski<float>& TestMap=(*pTestMap);
     363  SphereHEALPix<r_4>* pTestMap;
     364  pTestMap= new SphereHEALPix<r_4>(64);
     365  SphereHEALPix<r_4>& TestMap=(*pTestMap);
    369366
    370367#ifndef __MWERKS__

  • trunk/SigPredictor/abslightsource.h

    r801 r1148  
    11// Dominique YVON, CEA/DAPNIA/SPP 02/2000
     2// Les coordonnees spheriques utilisees par defaut sont: coordonŽes galactiques J2000
    23
    34#ifndef AbsLightSource_H

  • trunk/SigPredictor/abslobenopolar.cc

    r801 r1148  
    33#include <math.h>
    44#ifdef __MWERKS__
    5    #include "mwerksmath.h"
    65//   #include "unixmac.h"
    76#endif

  • trunk/SigPredictor/abslobenopolar.h

    r801 r1148  
    55
    66#ifdef __MWERKS__
    7    #include "mwerksmath.h"
    87//   #include "unixmac.h"
    98   #include "macenvvariables.h"

  • trunk/SigPredictor/fastlobes.h

    r801 r1148  
    66#include <math.h>
    77#ifdef __MWERKS__
    8    #include "mwerksmath.h"
    98   #include "unixmac.h"
    109#endif
    … …  
    2322                sprintf(Name,"Lobe Gaussien");
    2423    }
    25     virtual ~LobeGaussien(){ };
    26         virtual double weigthAmpl(const UnitVector& VInteg, const UnitVector& VP,
    27           const UnitVector& VY) const {
    28                 double cosinus=VP*VInteg;               
    29             if(cosinus>cosanglemax)
    30             {  if(cosinus<1.)
    31                 {       double ang= acos(cosinus);
     24   virtual ~LobeGaussien(){ };
     25   virtual double weigthAmpl(const UnitVector& VInteg, const UnitVector& VP,
     26          const UnitVector& VY) const
     27        {       double cosinus=VP*VInteg;               
     28           if(cosinus>cosanglemax)
     29           {  if(cosinus<1.)
     30                {       double ang= acos(cosinus);
    3231                        //return tabFExp(-ang*ang/(2*sigma*sigma));
    33                         return exp(-ang*ang/(2*sigma*sigma));
    34                 }
    35                 else return 1.;
    36             }
     32                return exp(-ang*ang/(2*sigma*sigma));
     33              }
     34              else return 1.;
     35           }
    3736                else return 0.;
    3837        }
     38       
    3939        virtual double lobeResol() const{
    4040                return sigma*2.354/3.; // On veut pixeliser/calculer ˆ au moins FWHM/3.

  • trunk/SigPredictor/lightcmbprim.cc

    r801 r1148  
    55#include <math.h>
    66#include "lightcmbprim.h"
    7 #include "fitsioserver.h"
     7
     8#include "fitsspherehealpix.h"
    89
    910#ifdef __MWERKS__
    10    #include "mwerksmath.h"
    1111   #include "macenvvariables.h"
    1212#endif
    … …  
    2323  // On reserve la mŽmoire pour la carte gorski
    2424  try {
    25         pMap =new SphereGorski<float> (nlat);
     25        pMap =new SphereHEALPix<r_4> (nlat);
    2626  }
    2727  catch (bad_alloc) {
    … …  
    4242#endif
    4343
     44
     45  FITS_SphereHEALPix<r_4> FSphere(*pMap);
     46  FSphere.Read(filename);                               // Units:  Microkelvin
     47       
     48/*     
    4449  FitsIoServer FitsServer;
    45   FitsServer.load(*pMap,filename);      // Units:  Microkelvin
     50  FitsServer.load(*pMap,filename);
     51*/
    4652}
    4753

  • trunk/SigPredictor/lightcmbprim.h

    r801 r1148  
    33#ifndef LightCMBPrim_SEEN
    44#define LightCMBPrim_SEEN
    5 #include "spheregorski.h"
     5#include "spherehealpix.h"
    66#include "lightsrcsep.h"
    77
    … …  
    1515 protected:
    1616        double Variance;
    17     SphereGorski<float>*  pMap;
     17    SphereHEALPix<float>*  pMap;
    1818    int_4 nlat;
    1919   

  • trunk/SigPredictor/lightdiffdust.cc

    r801 r1148  
    66#include <math.h>
    77#ifdef __MWERKS__
    8    #include "mwerksmath.h"
    98   #include "unixmac.h"
    109   #include "macenvvariables.h"
    … …  
    1211//#include "integ.h"
    1312#include "lightdiffdust.h"
    14 #include "fitsioserver.h"
     13#include "fitsspherehealpix.h"
    1514
    1615LightDiffDust::LightDiffDust(int_4 nside=256) {
    … …  
    3736 
    3837  cout<<"Objet LightDiffDust :"<<endl;
    39   cout <<"Resolution de travail nlat= "<<nlat<<endl;
     38  cout<<"Resolution de travail nlat= "<<nlat<<endl;
    4039 
    41   try { pMap=new SphereGorski<float> (nlat);    }
     40  try { pMap=new SphereHEALPix<r_4> (nlat);     }
    4241  catch (bad_alloc) {
    4342    cerr<<"memory booking error Lightdiffdust constructor nlat= "<<nlat<<endl;
    … …  
    5756  if(nlat<1024) cerr<<"la carte avec nlat=1024 est dispo"<<endl;
    5857 
    59   FitsIoServer FitsServer;
    60   FitsServer.load((*pMap),filename);
    61                 // unite: MJy/st. Dixit Romain
     58  FITS_SphereHEALPix<r_4> FSphere(*pMap);
     59  FSphere.Read(filename);                       // unite: MJy/st. Dixit Romain
     60
    6261}
    6362

  • trunk/SigPredictor/lightdiffdust.h

    r801 r1148  
    33#ifndef LightDIFFDUST_SEEN
    44#define LightDIFFDUST_SEEN
    5 #include "spheregorski.h"
     5#include "spherehealpix.h"
    66#include "lightsrcsep.h"
    77
    … …  
    2020        double CorrelatedfreeWeight;
    2121    double nuPlanckfRef;
    22     SphereGorski<float>* pMap;         // Map units MJy from IRAS Data.
     22    SphereHEALPix<float>* pMap;         // Map units MJy from IRAS Data.
    2323   
    2424    virtual double powerDensAmpli(double theta,double phi){

  • trunk/SigPredictor/lightdipole.cc

    r801 r1148  
    66
    77#ifdef __MWERKS__
    8    #include "mwerksmath.h"
    98   #include "unixmac.h"
    109#endif

  • trunk/SigPredictor/lightgalaxnoresol.cc

    r801 r1148  
    55#include <math.h>
    66#ifdef __MWERKS__
    7    #include "mwerksmath.h"
    87   #include "unixmac.h"
    98   #include "macenvvariables.h"
    … …  
    1413#include "integ.h"
    1514#include "fitsioserver.h"
     15
    1616
    1717#include "lightgalaxnoresol.h"
    … …  
    5353  // On stocke le no de pixel de la carte guiderdonni correspondant au pixel ciel
    5454 
    55   try {pSphereIndex=new SphereGorski<uint_2>(nlat); }
     55  try {pSphereIndex=new SphereHEALPix<uint_2>(nlat); }
    5656  catch(bad_alloc) {
    5757        cerr<<"Memory booking error in LightGalaxNoResol: pSphereIndex"<<endl;
    … …  
    112112
    113113        FitsServer.load(UneCarte,filename);
     114
    114115//      cout<<"Carte Lue: "<<filename<<'\t'<<"FrŽquence: "<<dataFreq[noFreq]<<endl;
    115116       

  • trunk/SigPredictor/lightgalaxnoresol.h

    r801 r1148  
    44#define SKYGALAXNORESOL_SEEN
    55
    6 #include "spheregorski.h"
     6#include "spherehealpix.h"
    77#include "abslightsource.h"
    88#include "numrecipes.h"
    … …  
    3030   float* dataFreqDegueux;
    3131     // Idem. Ne sert que pour appeller la fonction NR Polint
    32    SphereGorski<uint_2>* pSphereIndex;
     32   SphereHEALPix<uint_2>* pSphereIndex;
    3333     // Tableau de correspondance no de pixel carte sphereGorski, carte guiderdonni
    3434

  • trunk/SigPredictor/lightgalaxresol.cc

    r801 r1148  
    99
    1010#ifdef __MWERKS__
    11    #include "mwerksmath.h"
    1211   #include "unixmac.h"
    1312   #include "macenvvariables.h"
    … …  
    4645
    4746// Booking of skymap of index
    48   try { pLightMap= new SphereGorski<uint_2> (nlat); }
     47  try { pLightMap= new SphereHEALPix<uint_2> (nlat); }
    4948  catch(bad_alloc){
    5049    cerr<<"Erreur Reservation de memoire classe LightGalacResol, nlat= "<<nlat<<endl;

  • trunk/SigPredictor/lightgalaxresol.h

    r801 r1148  
    44#define SKYGALAXRESOL_SEEN
    55
    6 #include "spheregorski.h"
     6#include "spherehealpix.h"
    77#include "numrecipes.h"
    88#include "abslightsource.h"
    … …  
    3333    r_4** ppPointSourceData;    // (Jansky, cad 10-26 W/m2/st/Hz)
    3434    //donnŽes sur chaque source a chaque frequence
    35     SphereGorski <uint_2>* pLightMap; 
     35    SphereHEALPix <uint_2>* pLightMap; 
    3636    //grand (!) tableau des pixels du ciel. Contient eventuellement l index de
    3737    // du tableau SourcesInBandPower, cad le no de la source.

  • trunk/SigPredictor/lightsrcmappowerinband.cc

    r801 r1148  
    22
    33#include "lightsrcmappowerinband.h"
    4 #include "fitsioserver.h"
     4#include "fitsspherehealpix.h"
    55
    66double LightSrcMapPowerInband::powerDensAmpli(double theta,double phi)
    … …  
    2424   if(MinFreq>MaxFreq) cerr<<"Erreur freq Min>freq Max in LightSrcMapPowerInband"<<endl;
    2525   
    26    try {        pMap=new SphereGorski<float> (nlat);    }
     26   try {        pMap=new SphereHEALPix<r_4> (nlat);     }
    2727   catch(bad_alloc) {
    2828      cerr<<"Memory booking error LightSrcMapPowerInband, nlat= "<<nlat<<endl;
    … …  
    3030   }
    3131   cout<<"On lit la carte "<<filename<<endl; 
    32    FitsIoServer FitsServer;
    33    FitsServer.load((*pMap),filename);
     32   
     33  FITS_SphereHEALPix<r_4> FSphere(*pMap);
     34  FSphere.Read(filename);
    3435}
    3536

  • trunk/SigPredictor/lightsrcmappowerinband.h

    r801 r1148  
    33#ifndef LightSsrcMap_H
    44#define LightSsrcMap_H
    5 #include "spheregorski.h"
     5#include "spherehealpix.h"
    66#include "lightsrcsep.h"
    77
    … …  
    1515        double freqMax;
    1616        double freqMin;
    17         SphereGorski<float>* pMap;
     17        SphereHEALPix<float>* pMap;
    1818        double SpectreAmpli;
    1919       

  • trunk/SigPredictor/lightsynchro.cc

    r801 r1148  
    44#include <stdlib.h>
    55#include <math.h>
    6 #include "spheregorski.h"
    7 #include "fitsioserver.h"
     6#include "spherehealpix.h"
     7#include "fitsspherehealpix.h"
    88#include "lightsynchro.h"
    99
    1010#ifdef __MWERKS__
    11    #include "mwerksmath.h"
    1211   #include "macenvvariables.h"
    1312#endif
    … …  
    2524  resolution=2*3.14159/4./nlat;         // Radians
    2625 
    27   try { pMap=new SphereGorski<float>(nlat);  }  // MJy/m2/Hz/st cad 10-20 W/m2/Hz/st
     26  try { pMap=new SphereHEALPix<r_4>(nlat);  }   // MJy/m2/Hz/st cad 10-20 W/m2/Hz/st
    2827  catch(bad_alloc) {
    2928    cerr<<"memory booking error LightSynchro constructor nlat= "<<nlat<<endl;
    … …  
    3534#endif
    3635  sprintf(filename,"%ssync_res%04i.fits",PATHDataLScr,nside);
    37   FitsIoServer FitsServer;
    38   FitsServer.load((*pMap),filename);
    39     // unite: MJy/m2/Hz/st.
     36 
     37  FITS_SphereHEALPix<r_4> FSphere(*pMap);
     38  FSphere.Read(filename);                               // unite: MJy/m2/Hz/st.
    4039};
    4140

  • trunk/SigPredictor/lightsynchro.h

    r801 r1148  
    66
    77#include "lightsrcsep.h"
    8 #include "spheregorski.h"
     8#include "spherehealpix.h"
    99
    1010
    … …  
    1717 double index;
    1818 double freqRef;
    19  SphereGorski<float> * pMap; // Map units unknown to be looked for
     19 SphereHEALPix<float> * pMap; // Map units unknown to be looked for
    2020 
    2121 virtual double spectre(double freq)

  • trunk/SigPredictor/lobecartographmoyen.cc

    r801 r1148  
    33#include <math.h>
    44#ifdef __MWERKS__
    5    #include "mwerksmath.h"
     5    
    66   #include "unixmac.h"
    77   #include "macenvvariables.h"

  • trunk/SigPredictor/lobes4pi.h

    r801 r1148  
    33#include <math.h>
    44#ifdef __MWERKS__
    5    #include "mwerksmath.h"
    65   #include "unixmac.h"
    76#endif

  • trunk/SigPredictor/makebolotimeline.cc

    r801 r1148  
    22
    33#include <iomanip.h>
     4#include <new>
    45#ifdef __MWERKS__
    56   #include "macenvvariables.h"
    … …  
    910
    1011#include "makebolotimeline.h"
     12//#include "fitsioserver.h"
    1113
    1214
    1315MakeBoloTimeline::MakeBoloTimeline(char file[], AbsLightSource& LSrc,
    14                 AbsLobeNoPolar& Lobe, SpectralResponse &Filter, Normalisation Norm)
    15         :tool(&LSrc,&Lobe,&Filter), NormMethode(Norm)
    16 {
     16        AbsLobeNoPolar& Lobe, SpectralResponse& Filter, Normalisation Norm)
     17{       IsSigCalctool=true;
     18        IsPtSrcInBandtool=false;
     19        pSigCalcTool=new SigCalcTool(&LSrc,&Lobe,&Filter);
     20        MakeBoloTimeline(file,*pSigCalcTool,Norm);
     21}
     22
     23MakeBoloTimeline::MakeBoloTimeline(char file[], LightPtSrcLevSInBand& LSrc,
     24        MeanFreqLobe& Lobe, LevSPanckBand band, Normalisation Norm)
     25{       IsSigCalctool=false;
     26        IsPtSrcInBandtool=true;
     27       
     28        pPtSrcInBandCalTools=new PtSrcInBandCalTools(&LSrc,&Lobe,band);
     29        MakeBoloTimeline(file,*pPtSrcInBandCalTools,Norm);
     30}
     31
     32MakeBoloTimeline::MakeBoloTimeline(char file[], AbsCalcTool& Tool, Normalisation Norm)
     33        :NormMethode(Norm), ptool(&Tool)
     34{       
     35
    1736#ifndef __MWERKS__
    1837  char* PATHResults=getenv("PATHResults");
    1938#endif
     39
     40        saveReadMe(file);
     41       
    2042        char filecur[150];
    21 // On remplit le ReadMe
    22         sprintf(filecur,"%s%s.ReadMe", PATHResults,file);
     43        sprintf(filecur,"%s%s.dat", PATHResults,file);
     44       
     45        pMystr= new ofstream(filecur,ios::out|ios::trunc);
     46//      pMystr->setf(ios::scientific);
     47        (*pMystr)<<setprecision(5);
     48       
     49#ifdef VisuIsActive
     50        // Visu de controle
     51        try
     52        {       pSphere=new SphereHEALPix<r_4>(64);
     53                pSphereInt=new SphereHEALPix<uint_2>(64);
     54        }
     55        catch (bad_alloc)
     56        {       cerr<<"bad alloc in MakeBoloTimeline:"<<file<<endl;
     57        }
     58
     59        sprintf(Name, "%s%s%s",PATHResults,file,".visu");
     60#endif
     61}
     62
     63
     64MakeBoloTimeline::~MakeBoloTimeline()
     65{
     66        (*pMystr)<<flush;
     67        pMystr->close();
     68        delete pMystr;
     69
     70        if(IsSigCalctool) delete pSigCalcTool;
     71        if(IsPtSrcInBandtool) delete pPtSrcInBandCalTools;
     72
     73#ifdef VisuIsActive
     74        for(long index=0; index<(*pSphere).NbPixels();index++)
     75                if ((*pSphereInt).PixVal(index)!=0)
     76                        (*pSphere).PixVal(index)=(*pSphere).PixVal(index)/(*pSphereInt).PixVal(index);
     77       
     78//      FitsIoServer FitsServer;
     79        #ifndef __MWERKS__
     80                 char* PATHResults=getenv("PATHResults");
     81        #endif
     82
     83//      FitsServer.Mollweide_picture_projection((*pSphere),Name);  // BUGG XXXXXXXXX
     84       
     85        delete pSphere;
     86        delete pSphereInt;
     87#endif
     88}
     89
     90void MakeBoloTimeline::addToStreamArchTOI(double theta,double phi)
     91{       //       Theta en heures, Phi en degres, systeme RA Dec
     92        if((theta==ERROR_LABEL)||(phi==ERROR_LABEL)) return;
     93       
     94        // On passe en Radian
     95        double thetaRad=theta*15./180*M_PI;
     96        double phiRad=phi/180.*M_PI;
     97       
     98        // Go to Galactic ccordinates
     99        double lgalax=0.;               
     100        double bgalax=0.;
     101        kmg_eulerRad(thetaRad,phiRad,1,&lgalax,&bgalax);
     102       
     103        // Add to time line
     104        addToStream(lgalax,bgalax);
     105}
     106
     107void MakeBoloTimeline::addToStream(double lgalax,double bgalax)
     108{       // lgalax et bgalax en Radian, Systeme coord Galactique J2000
     109
     110        double theta=M_PI/2.-bgalax;    // Coordonnees Spheriques galactiques
     111        double phi=lgalax;     
     112        double value;
     113       
     114        switch (NormMethode)
     115        {
     116                case RayleighJeans:     // Value en TempeRJ
     117                {       value= NormRJ*ptool->compPixelQD(theta,phi);
     118                        break;
     119                }
     120                case TempeCMB:  // Value en tempeCMB
     121                {       value= NormTCMB*ptool->compPixelQD(theta,phi);
     122                        break;
     123                }
     124                default:                // Value en power
     125                {       value   =ptool->compPixelQD(theta,phi);
     126                        break;
     127                }
     128        }
     129                (*pMystr)<<lgalax<<'\t'<<bgalax<<'\t'<<value<<'\n';
     130               
     131                long PixelNumb=(*pSphere).PixIndexSph(theta,phi);
     132                (*pSphere).PixVal(PixelNumb)+=value;
     133                (*pSphereInt).PixVal(PixelNumb)++;
     134               
     135        return;
     136}
     137
     138void  MakeBoloTimeline::saveReadMe(char File[])
     139{       char filecur[150];
     140        // Fill Header file for ascii output
     141        sprintf(filecur,"%s%s.ReadMe", PATHResults,File);
    23142        cout<<filecur<<endl;
    24143        ofstream ReadMe(filecur,ios::out|ios::trunc);
    25144       
    26145        ReadMe<<" Fichier de timeline pour:"<<endl;
    27         ReadMe<<" La source physique: "<<endl;
    28         LSrc.print(ReadMe);
    29         ReadMe<<" Le Lobe : "<<endl;
    30         Lobe.print(ReadMe);
    31         ReadMe<<" Le Filtre: "<<endl;
    32         Filter.Print(ReadMe);   
    33         ReadMe<<endl;
     146        ptool->print(ReadMe);
    34147       
    35         NormRJ=tool.NormKelvinRayleighJeans();
    36         NormTCMB=tool.NormKelvinCMB();
     148        NormRJ=ptool->NormKelvinRayleighJeans();
     149        NormTCMB=ptool->NormKelvinCMB();
    37150       
    38 //      ReadMe.setf(ios::scientific);
    39151        ReadMe<< setprecision(3);
    40152        ReadMe<<" Constantes de normalisation"<<endl;
    … …  
    55167                default: ReadMe<< "Watt/m2 effectif de mirroir"<<endl;
    56168        }
    57         ReadMe<<"Fichier ecrit selon le format"<<endl;
    58         ReadMe<<"Radian\tRadian\tAbove Unit"<<endl;
     169       
     170        ReadMe<<"Fichier coordonŽes galactique J2000ecrit selon le format"<<endl;
     171        ReadMe<<"l_galax(Radian)\tb_galax(Radian)\tAbove Unit"<<endl;
    59172       
    60173        // J'espere que c'est assez
    61174        ReadMe.close();
    62175       
    63         sprintf(filecur,"%s%s.dat", PATHResults,file);
    64        
    65         pMystr= new ofstream(filecur,ios::out|ios::trunc);
    66 //      pMystr->setf(ios::scientific);
    67         (*pMystr)<<setprecision(5);
     176        return;
    68177}
    69178
    70 void MakeBoloTimeline::addToStreamArchTOI(double theta,double phi)
    71 {       //       Theta en heures, Phi en degres
    72         if((theta==ERROR_LABEL)||(phi==ERROR_LABEL)) return;
    73         double thetaRad=theta*15./180*M_PI;
    74         double phiRad=phi/180.*M_PI;
    75        
    76         addToStream(theta,phi);
    77 }
    78 
    79 void MakeBoloTimeline::addToStream(double theta,double phi)
    80 {       // theta et Phi en Radian.     
    81         switch (NormMethode)
    82         {
    83                 case RayleighJeans:
    84                 {       double TempeRJ= NormRJ*tool.compPixel(theta,phi);
    85                         (*pMystr)<<theta<<'\t'<<phi<<'\t'<<TempeRJ<<'\n';
    86                         return;
    87                 }
    88                 case TempeCMB:
    89                 {       double tempeCMB= NormTCMB*tool.compPixel(theta,phi);
    90                         (*pMystr)<<theta<<'\t'<<phi<<'\t'<<tempeCMB<<'\n';
    91                         return;
    92                 }
    93                 default:
    94                 {       double power=tool.compPixel(theta,phi);
    95                         (*pMystr)<<theta<<'\t'<<phi<<'\t'<<power<<'\n';
    96                         return;
    97                 }
    98         }
    99 }

  • trunk/SigPredictor/makebolotimeline.h

    r801 r1148  
    99#include "abslobenopolar.h"
    1010#include "sigcalctools.h"
     11#include "ptsrcinbandcalctools.h"
     12
    1113#include "specresp.h"
     14#include "spherehealpix.h"
     15
     16#define VisuIsActive
     17
    1218
    1319enum Normalisation { RayleighJeans, TempeCMB, Power};
    … …  
    1521{       
    1622public:
    17         MakeBoloTimeline(char file[], AbsLightSource& LSrc,
    18         AbsLobeNoPolar& Lobe, SpectralResponse &Filter, Normalisation Norm);
    19         ~MakeBoloTimeline()
    20         {       pMystr->close();
    21                 delete pMystr;
    22         }       
     23        MakeBoloTimeline(char file[], AbsCalcTool& Tool, Normalisation Norm);
     24        MakeBoloTimeline(char file[], AbsLightSource& LSrc, AbsLobeNoPolar& Lobe,
     25                SpectralResponse& Filter, Normalisation Norm);
     26        MakeBoloTimeline(char file[], LightPtSrcLevSInBand& LSrc,
     27                MeanFreqLobe& Lobe, LevSPanckBand band, Normalisation Norm);
     28        ~MakeBoloTimeline();
    2329        void addToStreamArchTOI(double theta, double phi);
    24                 //       Theta en heures, Phi en degres
    25         void addToStream(double theta,double phi);
    26                 // theta et phi en radian
     30                //       Theta en heures, Phi en degres, coordonnŽes RA Dec
     31        void addToStream(double lgalax,double bgalax);
     32                // theta et phi en radian, coordonŽes galactiques J2000.
     33
    2734protected:
    28         SigCalcTool tool;
    29         ofstream* pMystr;
     35        AbsCalcTool* ptool;
     36       
     37        SigCalcTool* pSigCalcTool;
     38        bool IsSigCalctool;
     39        PtSrcInBandCalTools* pPtSrcInBandCalTools;
     40        bool IsPtSrcInBandtool;
     41       
    3042        double NormRJ;
    3143        double NormTCMB;
    3244        Normalisation NormMethode;
     45       
     46        // Outils de fichier sortie
     47        ofstream* pMystr;               // Fichier ascii des valeurs physiques simulees
     48       
     49        void saveReadMe(char File[]);           // ReadMe file for ASCII output
     50       
    3351//      long flushControl;
     52
     53#ifdef VisuIsActive
     54        SphereHEALPix<r_4>* pSphere;            // Pour creer une visu de controle
     55        SphereHEALPix<uint_2>* pSphereInt;
     56        char Name[200];
     57#endif
    3458
    3559};

  • trunk/SigPredictor/maketimeline.cc

    r798 r1148  
    44#include <stdlib.h>
    55#include <iostream>
     6
     7
    68#include "makebolotimeline.h"
    79#include "bruit.h"
    … …  
    911
    1012#ifdef __MWERKS__
     13        #include "dyyield.h"
    1114   #include "macenvvariables.h"
    1215   #define SetNlatLSource (256)         // version debug
    13    #define NbSAMPLE (2000)                      //      Pour le debug
     16   #define NbSAMPLE (200000)                    //      Pour le debug
    1417#else
    1518   # define ERROR_LABEL -32768
    … …  
    1922
    2023
     24
    2125#include "alllobe.h"
    2226#include "alllightsources.h"
    2327#include "sigcalctools.h"
    2428#include "allfilter.h"
    25 #include "fitsioserver.h"
    26 
    2729
    2830
    … …  
    3234int MakeArcheopsTimelines(char FilePointes[])
    3335{
    34 
    35 /*
    3636
    3737// On genre des timelines de bruit en 1/f
    … …  
    3939        GenTimLin1_F(NbSAMPLE,5.83e-3,0.5);
    4040        GenTimLin1_F(NbSAMPLE,5.83e-3,0.1);
    41 */
     41
    4242       
    4343// On passe aux cartes de fonds physiques
    4444// Initialisations
    45    FitsIoServer FitsServer;
    4645   char filename[150]="";
    4746     
    … …  
    120119        // Bolo 2_4 soit bolo9.
    121120        sprintf(fileOut, "ASigPred_bolo2_4Dipole");
    122         MakeBoloTimeline TL2_4Dipole(fileOut, CMBDipole,GLobeTrapChan1,
    123                 FiltreTrapChan1,RayleighJeans);
     121        MakeBoloTimeline TL2_4Dipole(fileOut, CMBDipole,GLobeTrapChan2,
     122                FiltreTrapChan2,RayleighJeans);
    124123
    125124        sprintf(fileOut, "ASigPred_bolo2_4CMBPrim");
    126         MakeBoloTimeline TL2_4CMBPrim(fileOut, CMBPrim,GLobeTrapChan1,
    127                 FiltreTrapChan1,RayleighJeans);
     125        MakeBoloTimeline TL2_4CMBPrim(fileOut, CMBPrim,GLobeTrapChan2,
     126                FiltreTrapChan2,RayleighJeans);
    128127               
    129128        sprintf(fileOut, "ASigPred_bolo2_4DiffDust");
    130         MakeBoloTimeline TL2_4DiffDust(fileOut,DiffDust,GLobeTrapChan1,
    131                 FiltreTrapChan1,RayleighJeans);
     129        MakeBoloTimeline TL2_4DiffDust(fileOut,DiffDust,GLobeTrapChan2,
     130                FiltreTrapChan2,RayleighJeans);
    132131               
    133132        // Bolo 2_5 soit bolo4.
    134133        sprintf(fileOut, "ASigPred_bolo2_5Dipole");
    135         MakeBoloTimeline TL2_5Dipole(fileOut, CMBDipole,GLobeTrapChan1,
    136                 FiltreTrapChan1,RayleighJeans);
     134        MakeBoloTimeline TL2_5Dipole(fileOut, CMBDipole,GLobeTrapChan2,
     135                FiltreTrapChan2,RayleighJeans);
    137136
    138137        sprintf(fileOut, "ASigPred_bolo2_5CMBPrim");
    139         MakeBoloTimeline TL2_5CMBPrim(fileOut, CMBPrim,GLobeTrapChan1,
    140                 FiltreTrapChan1,RayleighJeans);
     138        MakeBoloTimeline TL2_5CMBPrim(fileOut, CMBPrim,GLobeTrapChan2,
     139                FiltreTrapChan2,RayleighJeans);
    141140
    142141        sprintf(fileOut, "ASigPred_bolo2_5DiffDust");
    143         MakeBoloTimeline TL2_5DiffDust(fileOut,DiffDust,GLobeTrapChan1,
    144                 FiltreTrapChan1,RayleighJeans);
     142        MakeBoloTimeline TL2_5DiffDust(fileOut,DiffDust,GLobeTrapChan2,
     143                FiltreTrapChan2,RayleighJeans);
    145144                               
    146145        // Bolo 3_6 soit bolo15.
    147146        sprintf(fileOut, "ASigPred_bolo3_6Dipole");
    148         MakeBoloTimeline TL3_6Dipole(fileOut, CMBDipole,GLobeTrapChan1,
    149                 FiltreTrapChan1,RayleighJeans);
     147        MakeBoloTimeline TL3_6Dipole(fileOut, CMBDipole,GLobeTrapChan3,
     148                FiltreTrapChan3,RayleighJeans);
    150149       
    151150        sprintf(fileOut, "ASigPred_bolo3_6CMBPrim");
    152         MakeBoloTimeline TL3_6CMBPrim(fileOut, CMBPrim,GLobeTrapChan1,
    153                 FiltreTrapChan1,RayleighJeans);
     151        MakeBoloTimeline TL3_6CMBPrim(fileOut, CMBPrim,GLobeTrapChan3,
     152                FiltreTrapChan3,RayleighJeans);
    154153
    155154        sprintf(fileOut, "ASigPred_bolo3_6DiffDust");
    156         MakeBoloTimeline TL3_6DiffDust(fileOut,DiffDust,GLobeTrapChan1,
    157                 FiltreTrapChan1,RayleighJeans);
     155        MakeBoloTimeline TL3_6DiffDust(fileOut,DiffDust,GLobeTrapChan3,
     156                FiltreTrapChan3,RayleighJeans);
    158157               
    159158               
    … …  
    197196                if (nbParamLu!=11) {
    198197                        cerr<<" Problme a la lecture du fichier: "<<FileName<<endl;
    199                         cerr<<" Ligne :"<<compteur<<endl;
     198                        cerr<<" Ligne :"<<Line<<endl;
    200199                }
    201                
    202         // On remplit les fichiers correspondants
    203                 TL1_1Dipole.addToStreamArchTOI(alphaBolo1_1,deltaBolo1_1);
    204                 TL1_1CMBPrim.addToStreamArchTOI(alphaBolo1_1,deltaBolo1_1);
    205                 TL1_1DiffDust.addToStreamArchTOI(alphaBolo1_1,deltaBolo1_1);
    206                
    207                 TL1_3Dipole.addToStreamArchTOI(alphaBolo1_3,deltaBolo1_3);
    208                 TL1_3CMBPrim.addToStreamArchTOI(alphaBolo1_3,deltaBolo1_3);
    209                 TL1_3DiffDust.addToStreamArchTOI(alphaBolo1_3,deltaBolo1_3);
    210                
    211                 TL2_4Dipole.addToStreamArchTOI(alphaBolo2_4,deltaBolo2_4);
    212                 TL2_4CMBPrim.addToStreamArchTOI(alphaBolo2_4,deltaBolo2_4);
    213                 TL2_4DiffDust.addToStreamArchTOI(alphaBolo2_4,deltaBolo2_4);
    214                
    215                 TL2_5Dipole.addToStreamArchTOI(alphaBolo2_5,deltaBolo2_5);
    216                 TL2_5CMBPrim.addToStreamArchTOI(alphaBolo2_5,deltaBolo2_5);
    217                 TL2_5DiffDust.addToStreamArchTOI(alphaBolo2_5,deltaBolo2_5);
    218                
    219                 TL3_6Dipole.addToStreamArchTOI(alphaBolo3_6,deltaBolo3_6);
    220                 TL3_6CMBPrim.addToStreamArchTOI(alphaBolo3_6,deltaBolo3_6);
    221                 TL3_6DiffDust.addToStreamArchTOI(alphaBolo3_6,deltaBolo3_6);
    222                
    223                 compteur++;
    224                 if((compteur%1000)==0)
    225                 {       double pourcent=100.*compteur/NbSAMPLE;
    226                         cout<<"Compteur= "<<compteur<<endl;
    227                         cout<<"Travail effectue a :"<<pourcent<<" %"<<endl;
     200                else
     201                {
     202                // On remplit les fichiers correspondants
     203                        TL1_1Dipole.addToStreamArchTOI(alphaBolo1_1,deltaBolo1_1);
     204                        TL1_1CMBPrim.addToStreamArchTOI(alphaBolo1_1,deltaBolo1_1);
     205                        TL1_1DiffDust.addToStreamArchTOI(alphaBolo1_1,deltaBolo1_1);
     206                       
     207                        TL1_3Dipole.addToStreamArchTOI(alphaBolo1_3,deltaBolo1_3);
     208                        TL1_3CMBPrim.addToStreamArchTOI(alphaBolo1_3,deltaBolo1_3);
     209                        TL1_3DiffDust.addToStreamArchTOI(alphaBolo1_3,deltaBolo1_3);
     210                       
     211                        TL2_4Dipole.addToStreamArchTOI(alphaBolo2_4,deltaBolo2_4);
     212                        TL2_4CMBPrim.addToStreamArchTOI(alphaBolo2_4,deltaBolo2_4);
     213                        TL2_4DiffDust.addToStreamArchTOI(alphaBolo2_4,deltaBolo2_4);
     214                       
     215                        TL2_5Dipole.addToStreamArchTOI(alphaBolo2_5,deltaBolo2_5);
     216                        TL2_5CMBPrim.addToStreamArchTOI(alphaBolo2_5,deltaBolo2_5);
     217                        TL2_5DiffDust.addToStreamArchTOI(alphaBolo2_5,deltaBolo2_5);
     218                       
     219                        TL3_6Dipole.addToStreamArchTOI(alphaBolo3_6,deltaBolo3_6);
     220                        TL3_6CMBPrim.addToStreamArchTOI(alphaBolo3_6,deltaBolo3_6);
     221                        TL3_6DiffDust.addToStreamArchTOI(alphaBolo3_6,deltaBolo3_6);
     222               
     223                        compteur++;
     224                               
     225        #ifdef __MWERKS__
     226                        DY_yield();
     227        #endif
     228                       
     229                        if((compteur%1000)==0)
     230                        {       cout<<"Compteur= "<<compteur<<endl;
     231                /*              //      Version Debug a commenter
     232                                double pourcent=100.*compteur/NbSAMPLE;
     233                                cout<<"Travail effectue a :"<<pourcent<<" %"<<endl;
     234                */      }
     235               
     236                        if(compteur==NbSAMPLE)
     237                        {       cout<<" Arret sur option de debugging"<<endl;           //BUGGG
     238                                break;
     239                        }
    228240                }
    229241        }
    … …  
    251263}
    252264
     265#include "fitstarray.h"
    253266
    254267int GenTimLin1_F(long Nbsample, double TStep, float fknee)
    … …  
    287300       
    288301// Write my fitFile, Version avec FitsIOServer
    289         FitsIoServer FitsServer;
    290         sprintf(filecur,"%sTimLineNoisetot%2.2f.fits",PATHResults,fknee);/* name for new FITS file */
    291         FitsServer.save(Array,filecur);
    292     
     302        sprintf(filecur,"%sTimLineNoisetot%2.2f.fits",PATHResults,fknee);/* name for new FITS file */   
     303        FITS_TArray <float> FTArray(Array);
     304        FTArray.Write(filecur);
     305 
    293306        return 0;
    294307}

  • trunk/SigPredictor/meanlobe.h

    r801 r1148  
    1919  }
    2020  virtual ~MeanFreqLobe() {delete pRespShape;}
     21  DistribFlatFilter* pRespShape;
     22                // Units conversion tools
    2123protected:
    2224        double One_ExcurFreq;           
    … …  
    2527                return One_ExcurFreq;
    2628        }
    27        
    28     DistribFlatFilter* pRespShape;
    29                 // Units conversion tools
    3029};
    3130

  • trunk/SigPredictor/numrecipes.h

    r801 r1148  
    66#include <math.h>
    77#ifdef __MWERKS__
    8    #include "mwerksmath.h"
    98   #include "unixmac.h"
    109#endif

  • trunk/SigPredictor/quasiptsources.cc

    r801 r1148  
    55#include <math.h>
    66#ifdef __MWERKS__
    7    #include "mwerksmath.h"
     7    
    88//   #include "unixmac.h"
    99#endif

  • trunk/SigPredictor/sigcalchackingtools.cc

    r801 r1148  
    55#include <fstream>
    66#ifdef __MWERKS__
    7    #include "mwerksmath.h"
     7    
    88   #include "unixmac.h"
    99#endif
    … …  
    1212//#include "integ.h"
    1313 
     14 int kmg_eulerRad(double ai, double bi, int select, double *ao, double *bo) {
     15  // All coordinates are in Radian.
     16  /* kmg_euler.c
     17   *
     18   * Converts between different coordinate systems.
     19   *
     20   * SELECT   From           To         |   SELECT    From          To
     21   *    1     RA-Dec (2000)  Galactic   |     4       Ecliptic      RA-Dec   
     22   *    2     Galactic       RA-DEC     |     5       Ecliptic
     23Galactic 
     24   *    3     RA-Dec         Ecliptic   |     6       Galactic
     25Ecliptic 
     26   *
     27   *    Date     Programmer Remarks
     28   * ----------- ---------- -------
     29   * 08-Aug-1999 K. Ganga   First version. Copied and modified EULER from
     30   *                        the IDL Astrolib.
     31   * May 2000, D. Yvon          Change coordinates units to Radians
     32   */
     33
     34  /* Local Declarations */
     35  double       a, b, sb, cb, cbsa;
     36  long         i;
     37  const double TWOPI   = 2.0*M_PI;
     38  const double FOURPI  = 4.0*M_PI;
     39  const double DEG2RAD = 180.0/M_PI;
     40
     41  /* J2000 coordinate conversions are based on the following constants
     42   * eps    =  23.4392911111  Obliquity of the ecliptic
     43   * alphaG = 192.85948       Right Ascension of Galactic North Pole
     44   * deltaG =  27.12825       Declination of Galactic North Pole
     45   * lomega =  32.93192       Galactic longitude of celestial equator
     46   * alphaE = 180.02322       Ecliptic longitude of Galactic North Pole
     47   * deltaE =  29.811438523   Ecliptic latitude of Galactic North Pole
     48   * Eomega =   6.3839743     Galactic longitude of ecliptic equator
     49   */
     50
     51  const double psi[6]    = {0.57477043300, 4.9368292465 ,
     52                            0.00000000000, 0.0000000000 ,
     53                            0.11142137093, 4.71279419371};
     54  const double stheta[6] = {0.88998808748,-0.88998808748,
     55                            0.39777715593,-0.39777715593,
     56                            0.86766622025,-0.86766622025};   
     57  const double ctheta[6] = {0.45598377618, 0.45598377618,
     58                            0.91748206207, 0.91748206207,
     59                            0.49714719172, 0.49714719172};
     60  const double phi[6]    = {4.9368292465 , 0.57477043300,
     61                            0.0000000000 , 0.00000000000,
     62                            4.71279419371, 0.11142137093};
     63
     64  i    = select - 1;
     65  a    = ai - phi[i];
     66  b    = bi;
     67  sb   = sin(b);
     68  cb   = cos(b);
     69  cbsa = cb*sin(a);
     70  b    = -stheta[i]*cbsa + ctheta[i]*sb;
     71  b    = ( (b >  1.0) ?  1.0 : b );
     72  b    = ( (b < -1.0) ? -1.0 : b );
     73  *bo  = asin(b);
     74
     75  a    = atan2( ctheta[i] * cbsa + stheta[i] * sb, cb * cos(a) );
     76  *ao  = fmod(a + psi[i] + FOURPI, TWOPI);
     77
     78  /* Later */
     79  return 0;
     80}
     81
     82
    1483template <class T> void addToSkyMap(PixelMap<T>& Map, SigCalcTool& Tool)
    1584{

  • trunk/SigPredictor/sigcalctools.cc

    r801 r1148  
    66#include <fstream>
    77#ifdef __MWERKS__
    8    #include "mwerksmath.h"
     8    
    99   #include "unixmac.h"
    1010#endif
    … …  
    3535
    3636SigCalcTool::SigCalcTool(AbsLightSource* pLightSrc, AbsLobeNoPolar* pLobeNoPolar,
    37         SpectralResponse* pFilt):pLSrc(pLightSrc),pLobe(pLobeNoPolar),pFilter(pFilt)
    38 {       
     37        SpectralResponse* pFilt):pLSrc(pLightSrc)
     38{       pLobe=pLobeNoPolar;
     39        pFilter=pFilt;
     40       
    3941        SigCalcToolInit();
    4042}
    … …  
    9496}
    9597
    96 double SigCalcTool::compPixel(double theta,double phi) {
    97         UnitVector VP(theta,phi);
    98         UnitVector VYbidon=VP.VperpPhi();         
    99 // Compute unit vector perpendicular to Vpoin at same theta
    100         return compPixel(VP,VYbidon);
    101 }
     98
    10299
    103100double SigCalcTool::compPixel(UnitVector& VP, UnitVector& VdirectY){
    … …  
    273270}
    274271
    275 double SigCalcTool::NormKelvinRayleighJeans()
    276 {       
    277         double tempeCNoir=10000.;       
    278                                         // Kelvin
    279         double CutFreq=1.380662e-23*tempeCNoir/6.626176e-34/5.;
    280         if(FreqMax>1.380662e-23*tempeCNoir/6.626176e-34/5.)
    281         {       cerr<< "RaleighJeans approximation is not valid for this frequency"<<endl;
    282                 cerr<< "Frequency: "<< FreqMax<<" in SigCalcTool::NormRayleighJeans"<<endl;
    283         }
    284        
    285         LightBlackBody CorpsNoir(tempeCNoir, RAngComp);
    286         SigCalcTool ToolRJ(&CorpsNoir,pLobe,pFilter);
    287         double puissNorm = ToolRJ.compPixel(M_PI/2.,M_PI);      // Un pixel au hasard
    288         return tempeCNoir/puissNorm;                            // Kelvin RaleighJeans/(Watt/m2)
    289  
    290 }
    291  
    292 double SigCalcTool::NormKelvinCMB()
    293 {       
    294         double deltatempeCNoir=1.;                                      // Kelvin
    295         LightNormTCMB DeltaCorpsNoir(deltatempeCNoir, RAngComp);
    296         SigCalcTool ToolDeltaCMB(&DeltaCorpsNoir,pLobe,pFilter);
    297         double puissNorm = ToolDeltaCMB.compPixel(M_PI/2.,M_PI);        // Un pixel au hasard
    298         return deltatempeCNoir/puissNorm;                       // KelvinCMB/(Watt/m2)
    299  
    300 }
    301 
    302272/*
    303273double SigCalcTool::CalcInBandPower(double theta, double phi)
    … …  
    322292  else AngRes=RAngComp*pLobe->ResolutionCurve(angle);
    323293  return AngRes;
    324 }
    325 
    326 
    327 
    328 double SigCalcTool::max(double a, double b) const{
    329   if(a>b) return a;
    330   else return b;
    331 }
    332 
    333  double SigCalcTool::min(double a, double b) const{
    334   if(a<b) return a;
    335   else return b;
    336294}
    337295
    … …  
    432390 
    433391  return SizeInteg;
    434 }
    435  
    436 double SigCalcTool::diffSolidAng(double ang1,double ang2) const
    437 {       double returnVal;               // Steradians
    438         if(!pLSrc->IsPtSourceS()) returnVal= fabs(2*M_PI*(cos(ang1)-cos(ang2)));
    439                 // Cas d'une source Žtendue.
    440         else  returnVal= 1.;
    441                 // Cas d'une source ponctuelle. Sont flux est exprime en W/m2/Hz
    442                 // Pas d'angle solide.
    443         return returnVal;
    444                
    445392}
    446393
    … …  
    513460}
    514461
     462double SigCalcTool::diffSolidAng(double ang1,double ang2) const
     463{       double returnVal;               // Steradians
     464        if(!pLSrc->IsPtSourceS()) returnVal= fabs(2*M_PI*(cos(ang1)-cos(ang2)));
     465                // Cas d'une source Žtendue.
     466        else  returnVal= 1.;
     467                // Cas d'une source ponctuelle. Sont flux est exprime en W/m2/Hz
     468                // Pas d'angle solide.
     469        return returnVal;
     470}
     471
    515472template void addInInBandPowerMap(PixelMap<float>& Map, SigCalcTool& tool);
    516473template void addInInBandPowerMap(PixelMap<double>& Map, SigCalcTool& tool);

  • trunk/SigPredictor/sigcalctools.h

    r801 r1148  
    44#define SigCalcTools_H
    55
    6 #include "pixelmap.h"
    76#include "abslightsource.h"
    8 #include "abslobenopolar.h"
    9 #include "specresp.h"
     7#include "abscalctool.h"
     8
    109#include "integ.h"
    1110
    1211enum CalcOptions {NonSeparable,AllSeparable,IsLightMapPowerInband};
    1312
    14 class SigCalcTool {
     13class SigCalcTool:public AbsCalcTool {
    1514friend double SigCalGLFreqFunc1(double freq);
    1615friend double SigCalGLFreqFunc2(double freq);
    … …  
    2625        SigCalcToolInit();
    2726 }
    28  double compPixel(double theta, double phi);
    29     // Return power on detector (Watt/m2) for this Lobe and filter
    30     // Pointing at these ccordinates.
    31     // Exact if lobes are symmetrical by rotation around pointed axe
    3227 
    3328 double compPixel(UnitVector& VP, UnitVector& VY);
    … …  
    3530    // Pointing at these ccordinates. with this telescope orientation
    3631    // Exact
    37  
     32   
     33 virtual void print(ostream& ReadMe)
     34 {      ReadMe<<" La source physique: "<<endl;
     35        pLSrc->print(ReadMe);
     36        ReadMe<<" Le Lobe : "<<endl;
     37        pLobe->print(ReadMe);
     38        ReadMe<<" Le Filtre: "<<endl;
     39        pFilter->Print(ReadMe);
     40        ReadMe<<endl;
     41 }
     42
    3843 double CalcLobeSize(double frequency= -10.);
    3944 // Calcule l'extension spatiale du lobe de cet outil
    … …  
    4348 // Doit EVOLUER SI powerInteg CHANGE;
    4449 
    45  double NormKelvinRayleighJeans();
    46         // Compute te normalisation factor to go from Watt/m2 to KelvinRaleighJeans
    47         // same computation option than the map options
    48         // KelvinRJ/(Watt/m2)
    49        
    50  double NormKelvinCMB();
    51         // Compute te normalisation factor to go from Watt/m2 to KelvinCMB
    52         // same computation option than the map options
    53         // KelvinCMB/(Watt/m2)
    54        
    55 // double CalcInBandPower(double theta, double phi);
    56         // return pwwer density (W/m2/st) integred over frequency response
    57         // of LSource, Filter and Lobe
    5850       
    5951// Ces fonctions servent au hackingtools. elle palient le fait que je n'ai pas reussi
    … …  
    6860 inline double getFreqMax() {return FreqMax;}
    6961 inline double getIntegSpectOverFreq() {return IntegSpectOverFreq;}
     62 
     63
    7064 
    7165protected:
    7266 AbsLightSource* pLSrc;
    73  AbsLobeNoPolar* pLobe;
    74  SpectralResponse* pFilter;
    7567 CalcOptions Option;    // Used to drives computations optimisations
    7668 GLInteg* pIntegrale;
    7769 
    7870 bool emptySignal;
    79  double RAngComp;               // angular resolution of computations
    80  
    81  double FreqMax;                // Hz
    82  double FreqMin;                // Hz
    8371 double IntegSpectOverFreq;
    8472
    … …  
    10290 double calcPowerDens() const;
    10391        // compute the power integrated on frequency dependance, (Lobe and LightSource and filter)
    104     // on pourra en avoir plusieur versions
     92   // on pourra en avoir plusieur versions
    10593 
    10694 double powerInteg();
    … …  
    11098        // WeigthVsFreq
    11199
    112  // Computation tools       
    113     // Math tools !!!!!!!-------------------------------------------------------
    114  inline double max(double a, double b)const;
    115  inline double min(double a, double b)const;
    116             //compute solid angle between cones of aperture angles ang1 and ang2
    117  
    118  inline double diffSolidAng(double ang1,double ang2) const;
     100 virtual double diffSolidAng(double ang1,double ang2) const;
    119101};
    120102
    121 // Tools for computing Maps
    122 template <class T> void addToSkyMap(PixelMap<T>& Map, SigCalcTool& Tool);
    123 template <class T> void compSkyMap(PixelMap<T>& Map, SigCalcTool& Tool);
    124 template <class T> void addInInBandPowerMap(PixelMap<T>& Map, SigCalcTool& tool);
    125         // Exact if lobes are symmetrical by rotation around pointed axe
    126         // Return a map at the requested resolution and frequency
    127 
    128 // Tools for manipulating maps 
    129 template <class T1, class T2> void addMap(PixelMap<T1>& Map, PixelMap<T2>& Map2);
    130 template <class T1, class T2> void substractMap(PixelMap<T1>& Map, PixelMap<T2>& Map2);
    131 template <class T1, class T2> void divMap1WithMap2(PixelMap<T1>& Map, PixelMap<T2>& Map2);
    132 template <class T> void scaleMap(double scalefactor, PixelMap<T>& Map);
    133 template <class T> int MinMaxSigMap(PixelMap<T>& Map, double& Min,
    134         double& Max, double& Moy, double& Var);
    135103
    136104#endif
Note: See TracChangeset for help on using the changeset viewer.