ProjectDatabaseManager.idl

Go to the documentation of this file.

#ifndef CARMA_OBSERVERTOOLS_PROJECTDATABASEMANAGER_IDL
#define CARMA_OBSERVERTOOLS_PROJECTDATABASEMANAGER_IDL

#include "carma/util/UserException.idl"
#include "carma/observertools/ItemValue.idl"

module carma {
module observertools {

        const string PROJECT_DATABASE_MANAGER_NAME =
                "carma.projectDatabaseManager.projectDatabaseManagerControl";

        exception ProjectDatabaseException {
                string errorMsg;
                string filename;
                short lineNo;
        };

        typedef sequence<string> StringSequence;

        enum EditStatus {
                ESTATUS_EDIT,         
                ESTATUS_ADD,          
                ESTATUS_DELETE,       
                ESTATUS_REPLICATE,    
                ESTATUS_RENAME,       
                ESTATUS_APPEND,       
                ESTATUS_REPLACE       
        };

        enum ProjectStatus {
                PSTATUS_COMPLETE,     
                PSTATUS_INCOMPLETE,   
                PSTATUS_RUNNING,      
                PSTATUS_OTHER
        };

        enum ObsCategory {
                CATEGORY_GALACTIC,           
                CATEGORY_COMET,              
                CATEGORY_PLANET,             
                CATEGORY_SOLAR,              
                CATEGORY_EXTRAGALACTIC,      
                CATEGORY_OTHER,              
                CATEGORY_STELLAR,            
                CATEGORY_HIGH_MASS_STAR_FORM,
                CATEGORY_LOW_MASS_STAR_FORM, 
                CATEGORY_CHEMISTRY_ISM,      
                CATEGORY_GALAXY_DETECTION,   
                CATEGORY_GALAXY_MAPPING,     
                CATEGORY_COSMOLOGY,          
                CATEGORY_OTHER_GALACTIC,     
                CATEGORY_OTHER_EXTRAGALACTIC 
        };

        enum ObsType {
                TYPE_SINGLEPOL,         
                TYPE_CARMA23,           
                TYPE_DUALPOL,           
                TYPE_FULLPOL,           
                TYPE_CARMA15,           
                TYPE_CARMA8,            
                TYPE_PACS,              
                TYPE_MAXSENS_DUALPOL,   
                TYPE_MAXSENS_CARMA23,   
                TYPE_MAXSENS_LL,        
                TYPE_NONE,
                TYPE_PACS_DUALPOL,
                TYPE_PACS_FULLPOL
        };

        enum ObsLikelihood {
                LIKELIHOOD_A,      
                LIKELIHOOD_B,      
                LIKELIHOOD_C,      
                LIKELIHOOD_NONE    
        };

        typedef sequence<short> shortSequence;

        typedef sequence<double> doubleSequence;

        struct Source {
                string sourceName;             
                boolean ephemeris;             
                double ra;                     
                double dec;                    
                string dataFile;               
                float velocity;                
                string veltype;                
                boolean isSelfcalibratable;    
                float observationLength;       
                shortSequence correlatorSetup; 
        };

        typedef sequence<Source> SourceSequence;

        struct Calibrator {
                string calibratorName;         
                string calType;                
                double ra;                     
                double dec;                    
                string dataFile;               
                float observationLength;
                shortSequence correlatorSetup; 
        };

        typedef sequence<Calibrator> CalibratorSequence;

        struct Investigator {
                string name;            
                string email;           
                string affiliation;     
                boolean isUsAffil;      
        };

        typedef sequence<Investigator> InvestigatorSequence;

        struct Window {
                short windowNumber;           
                double bandwidth;             
                double frequencyResolution;   
                short numberOfChannels;       
                double minFrequency;          
                double maxFrequency;          
        };

        typedef sequence<Window> WindowSequence;

        struct Correlator {
                short setupNumber;          
                short numberOfWindows;      
                WindowSequence window;      
        };

        typedef sequence<Correlator> CorrelatorSequence;

        struct Target {
                string molecule;    
                string transition;  
        };

        typedef sequence<Target> TargetSequence;

        struct Trial {
                string parentProject;                   
                string parentObsblock;                  
                string parentSubObsblock;               
                string documentName;
                short trialID;                          
                ProjectStatus status;                   
                float trialObservationLength;           
                string trialObservationDateStart;       
                string trialObservationDateEnd;
                double observedLSTstart;                
                double observedLSTend;
                boolean fastSwitch;                     
                float averagePhase;                     
                float averageOpacity;                   
                float dqaOverallGrade;                  
                float obsGrade;                         
                string obsComments;                     
                short numberOfPointings;                
                doubleSequence offsets;                 
                short numberOfAntennas;                 
                TargetSequence target;                  
                SourceSequence source;                  
                CalibratorSequence calibrator;          
                CorrelatorSequence correlator;          
                string imgVsSnr;                        
                float maxGaincalTime;                   
                float maxGaincalRms;                    
                short maxTsys;                          
                short minNumberOfAntennas;              
                float maxOpacity;                       
                float maxRmsPathLength;                 
                float maxDecorrelationRatio;            
                float requiredSourceRms;                
                // End of observing constraints
                string script;                          
                string catalog;                         
                string systemScripts;
                string scriptParameterization;
        };

        typedef sequence<Trial> TrialSequence;

        struct SubObsblock {
                string parentProject;                   
                string parentObsblock;                  
                string documentName;
                string subObsblockID;                   
                ProjectStatus status;                   
                float subObsblockObservationTime;       
                StringSequence parentSubObsblock;       
                StringSequence childSubObsblock;        
                short lastTrial;                        
                TrialSequence trial;                    
        };

        typedef sequence<SubObsblock> SubObsblockSequence;

        struct Obsblock {
                string parentProject;            
                string documentName;
                string obsblockID;               
                ProjectStatus status;            
                boolean exceedTAC;               
                float minAllocatedTime;          
                float maxAllocatedTime;          
                float priority;                  
                ObsLikelihood likelihood;        
                float totalObsTime;              
                float remainingTime;             
                float reqLowHourAngleCoverage;   
                float reqHiHourAngleCoverage;    
                double lowRa;                    
                double highRa;                   
                string actualHourAngleCoverage;  
                ObsType observationType;         
                string receiverBand;             
                float restFrequency;             
                string arrayConfiguration;       
                boolean isFlex;                  
                StringSequence parentObsblock;   
                StringSequence childObsblock;    
                SubObsblockSequence subObsblock; 
        };

        typedef sequence<Obsblock> ObsblockSequence;

        struct Project {
                string projectID;                      
                ProjectStatus status;                  
                string proposalTerm;                   
                float totalTime;                       
                string title;                          
                short numberOfInvestigators;           
                Investigator primaryInvestigator;      
                InvestigatorSequence coInvestigator;   
                boolean isTargetOfOpportunity;         
                boolean isKeyProject;                  
                boolean isFastTrack;                   
                boolean isCommissioning;               
                ObsCategory category;                  
                string projectAbstract;                
                StringSequence parentProject;          
                StringSequence childProject;           
                ObsblockSequence obsblock;             
        };

        typedef sequence<Project> ProjectSequence;

        interface ProjectDatabaseManager {

                // Check the database for consistency.
                void checkDatabase() raises(carma::util::UserException);

                // Query the database.
                ProjectSequence projectQuery(in ItemValueSequence theQuery)
                        raises(carma::util::UserException,
                                        carma::observertools::ProjectDatabaseException);

                // Query the database.
                // Same as projectQuery(), but uses an out parameter to return the results
                void projectQueryInOut(
                                in ItemValueSequence theQuery,
                                out ProjectSequence pSeq)
                        raises(carma::util::UserException,
                                        carma::observertools::ProjectDatabaseException);

                // Find and return the observing script for a project. It is returned as a
                // sequence of strings, one element for each line in the original script file.
                // The observing script from the last trial is returned, previous trials are
                // ignored.
                //
                // Various characters are replaced with escape sequences.
                // See ProjectDatabaseManagerUtils.cc replaceForbidden() for the exact list.
                StringSequence projectOscriptFind(
                                in string projectID,
                                in string obsblock,
                                in string subObsblock)
                        raises(carma::util::UserException,
                                        carma::observertools::ProjectDatabaseException);

                // Add an observing script and source catalog to the database.
                void projectOscriptAdd(
                                in string projectID,
                                in string obsblock,
                                in string subObsblock,
                                in string scriptFile,
                                in string catalogFile)
                        raises(carma::util::UserException,
                                        carma::observertools::ProjectDatabaseException);

                // Edit items in a project.
                boolean projectEdit(
                                in string projectID,
                                in string obsblock,
                                in string subObsblock,
                                in short trial,
                                in ItemValueSequence itemValueSeq,
                                in EditStatus action)
                        raises(carma::util::UserException,
                                        carma::observertools::ProjectDatabaseException);

                // Edit items in a project.
                // Same as projectEdit(), but uses an out parameter to return the status.
                void projectEditInOut(
                                in string projectID,
                                in string obsblock,
                                in string subObsblock,
                                in short trial,
                                in ItemValueSequence itemValueSeq,
                                in EditStatus action,
                                out boolean success)
                        raises(carma::util::UserException,
                                        carma::observertools::ProjectDatabaseException);

                // Add a project to the database, taking input from a file.
                void projectAdd(in string fileName)
                        raises(carma::util::UserException,
                                        carma::observertools::ProjectDatabaseException);

                // Add a project to the database, taking input from a string.
                boolean projectAddAsString(in string xmlString)
                        raises(carma::util::UserException,
                                        carma::observertools::ProjectDatabaseException);

                // Convert a numeric grade [0-100] into a letter grade.
                // See ProjectDatabaseManagerUtils.cc.
                string gradeToLetter(in float grade)
                        raises(carma::util::UserException);

                // Convert a letter grade (A+, A, A-, etc.) into a numeric grade [0-100].
                // See ProjectDatabaseManagerUtils.cc.
                float letterToGrade(in string letter)
                        raises(carma::util::UserException);

                // Run a trial of a project. This creates a new trial structure in the
                // database. The return value is the trial number.
                short runProject(
                                in string projectID,
                                in string obsblock,
                                in string subObsblock,
                                in boolean isCommissioning,
                                in boolean isDualCorr,
                                in string arrayConfig1,
                                in string arrayConfig2,
                                in string scriptFile,
                                in string catalogFile)
                        raises(carma::util::UserException,
                                        carma::observertools::ProjectDatabaseException);

                // Run a trial of a project.
                // Same as runProject(), but uses an out parameter to return the trial number.
                void runProjectInOut(
                                in string projectID,
                                in string obsblock,
                                in string subObsblock,
                                in boolean isCommissioning,
                                in boolean isDualCorr,
                                in string arrayConfig1,
                                in string arrayConfig2,
                                in string scriptFile,
                                in string catalogFile,
                                out short trialNumber)
                        raises(carma::util::UserException,
                                        carma::observertools::ProjectDatabaseException);

                // Returns true if and only if the project id is part of the
                // hardcoded list of commissioning projects in the source code.
                //
                // See ProjectDatabaseManagerUtils.cc for the list.
                boolean isCommissioning(in string pid)
                        raises(carma::util::UserException,
                                        carma::observertools::ProjectDatabaseException);

                // Check if the database is alive and responding to commands.
                // Returns the hardcoded value 4.
                short isUp()
                        raises(carma::util::UserException,
                                        carma::observertools::ProjectDatabaseException);
        };

}; // module carma::observertools
}; // module carma

#endif // CARMA_OBSERVERTOOLS_PROJECTDATABASEMANAGER_IDL

/* vim: set ts=4 sts=4 sw=4 noet: */