Spin.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004 by Olivier Stezowski                               *
 *   stezow(AT)ipnl.in2p3.fr                                                  *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
 
#ifndef ROOT_TString
#include <TString.h>
#endif

#include <iostream>
#include <sstream>

#ifndef GW_Spin
#include "Spin.h"
#endif

using namespace std;
using namespace Gw;

ClassImp(Spin);

Spin::Spin()
    : QNumber(), InfoData()
{
        fN = 0; fD = 1;
}

Spin::Spin(Int_t N, Int_t D)
    : QNumber(), InfoData()
{
        Set(N,D);
}

Spin::~Spin()
{
}

const Char_t* Spin::GetString() const 
{
  if (fD != 1)
    return Form("%d/%d", fN, fD);
  else
    return Form("%d", fN);
}

void Spin::Set(const char *s)
{
    std::istringstream input; input.clear(); TString st = s;
        switch( WhatIs(s) ){
                case kKnown:
                        if ( st.Contains('/') ) { // not an integer
                                st.ReplaceAll('/',' '); input.str(st.Data()); input >> fN >> fD;  
                        }
                        else { input.str(st.Data()); input >> fN; fD = 1; }
                        if ( input.fail() ) 
                                SetInfo(kUnknown);
                        else 
                                SetInfo(kKnown);
                        break;
                case kUnknown:
                        SetInfo(kUnknown);
                        break;  
                case kAbout:
                        st.ReplaceAll('~',' ');
                        if ( st.Contains('/') ) { // not an integer
                                st.ReplaceAll('/',' '); input.str(st.Data()); input >> fN >> fD;  
                        }
                        else { input.str(st.Data()); input >> fN; fD = 1; }             
                        if ( input.fail() ) 
                                SetInfo(kUnknown);
                        else 
                                SetInfo(kAbout);        
                        break;
                case kTentative:
                        st.ReplaceAll('(',' '); 
                        st.ReplaceAll(')',' '); 
                        if ( st.Contains('/') ) { // not an integer
                                st.ReplaceAll('/',' '); input.str(st.Data()); input >> fN >> fD;  
                        }
                        else { input.str(st.Data()); input >> fN; fD = 1; }
                        if ( input.fail() ) 
                                SetInfo(kUnknown);
                        else 
                                SetInfo(kTentative);    
                        break;
                case kTheo:
                        st.ReplaceAll('[',' '); 
                        st.ReplaceAll(']',' '); 
                        if ( st.Contains('/') ) { // not an integer
                                st.ReplaceAll('/',' '); input.str(st.Data()); input >> fN >> fD;  
                        }
                        else { input.str(st.Data()); input >> fN; fD = 1; }
                        if ( input.fail() ) 
                                SetInfo(kUnknown);
                        else 
                                SetInfo(kTheo); 
                        break;
                default:
                        SetInfo(kUnknown);
                        break;
        }
}

void Spin::Set(Int_t n, Int_t d)
{
    fN = n; fD = d;
    if ( fD < 1 || fD > 2 ) { 
        printf("- ! - A spin should be an integer or half an integer ! \n ");
        printf("\t [%d/%d] --> [%d/1] \n ",fN,fD,fN);
        fD = 1; 
    }
}

Spin& Spin::operator+=(Int_t value)
{
    fN += fD*value;
    return *this;
}

Spin& Spin::operator+=(Spin sp)
{
  if (fD == sp.fD) {
    fN += sp.fN;
  } else {
    fN = fD*sp.fN + fN*sp.fD;
    fD = TMath::Max(fD, sp.fD);
  }
  return *this;
}

std::ostream & operator << (std::ostream &out, const Spin &spin)
{
    string sep1, sep2;
    
    if ( spin.IsData(InfoData::kUnknown) ) {
        out << "?" ; 
                return out;
    }
    sep1 = sep2 = "";
    if ( spin.IsData(InfoData::kTentative) ) 
                { sep1 = '('; sep2 = ')'; }
    if ( spin.IsData(InfoData::kTheo) )      
                { sep1 = '['; sep2 = ']'; }    
    if ( spin.IsData(InfoData::kAbout) )     
                { sep1 = '~'; sep2 = ""; }  
         
    if ( spin.GetD() == 1 ) {
                out << sep1 << spin.GetN() << sep2 ; 
                return out;
    } 
    else { 
                out << sep1 << spin.GetN() << "/" << spin.GetD() << sep2; 
                return out; 
        } 
}