kalzium/src/kalziumgradienttype.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005, 2006      by Pino Toscano, toscano.pino@tiscali.it      *
   3  *                                                                         *
   4  *   This program is free software; you can redistribute it and/or modify  *
   5  *   it under the terms of the GNU General Public License as published by  *
   6  *   the Free Software Foundation; either version 2 of the License, or     *
   7  *   (at your option) any later version.                                   *
   8  *                                                                         *
   9  *   This program is distributed in the hope that it will be useful,       *
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  12  *   GNU General Public License for more details.                          *
  13  *                                                                         *
  14  *   You should have received a copy of the GNU General Public License     *
  15  *   along with this program; if not, write to the                         *
  16  *   Free Software Foundation, Inc.,                                       *
  17  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
  18  ***************************************************************************/
  19
  20 #include "kalziumgradienttype.h"
  21
  22 #include "element.h"
  23 #include "prefs.h"
  24 #include "kalziumdataobject.h"
  25
  26 #include <QVariant>
  27
  28 #include <klocale.h>
  29 #include <kdebug.h>
  30
  31 #include <math.h>
  32
  33 KalziumGradientTypeFactory::KalziumGradientTypeFactory()
  34 {
  35         m_gradients << KalziumCovalentRadiusGradientType::instance();
  36         m_gradients << KalziumVanDerWaalsRadiusGradientType::instance();
  37         m_gradients << KalziumMassGradientType::instance();
  38         m_gradients << KalziumBoilingPointGradientType::instance();
  39         m_gradients << KalziumMeltingPointGradientType::instance();
  40         m_gradients << KalziumElectronegativityGradientType::instance();
  41         m_gradients << KalziumElectronaffinityGradientType::instance();
  42         m_gradients << KalziumDiscoverydateGradientType::instance();
  43         m_gradients << KalziumIonizationGradientType::instance();
  44 }
  45
  46 KalziumGradientTypeFactory* KalziumGradientTypeFactory::instance()
  47 {
  48         static KalziumGradientTypeFactory kttf;
  49         return &kttf;
  50 }
  51
  52 KalziumGradientType* KalziumGradientTypeFactory::build( int id ) const
  53 {
  54         if ( ( id < 0 ) || ( id >= m_gradients.count() ) )
  55                 return 0;
  56
  57         return m_gradients.at( id );
  58 }
  59
  60 KalziumGradientType* KalziumGradientTypeFactory::build( const QByteArray& id ) const
  61 {
  62         for ( int i = 0; i < m_gradients.count(); i++ )
  63         {
  64                 if ( m_gradients.at( i )->name() == id )
  65                         return m_gradients.at( i );
  66         }
  67
  68         // not found
  69         return 0;
  70 }
  71
  72 QStringList KalziumGradientTypeFactory::gradients() const
  73 {
  74         QStringList l;
  75         for ( int i = 0; i < m_gradients.count(); i++ )
  76         {
  77                 l << m_gradients.at( i )->description();
  78         }
  79         return l;
  80 }
  81
  82
  83 KalziumGradientType::KalziumGradientType()
  84 {
  85 }
  86
  87 KalziumGradientType::~KalziumGradientType()
  88 {
  89 }
  90
  91 KalziumGradientType* KalziumGradientType::instance()
  92 {
  93         return 0;
  94 }
  95
  96 double KalziumGradientType::elementCoeff( int el ) const
  97 {
  98         double val = value( el );
  99         if( val <= 0.0 ) return -1;
 100
 101         if(logarithmicGradient()) {
 102                 double result = ( log(val) - log(minValue()) ) / ( log(maxValue()) - log(minValue()) );
 103
 104                 // now we perform a "gamma-correction" on the result. Indeed, logarithmic gradients
 105                 // often have the problem that all high values have roughly the same color. Note that
 106                 // as firstColor() is not necessarily black and secondColor() is not necessarily white,
 107                 // this is not exactly a "gamma-correction" in the usual sense.
 108                 const double gamma = 1.4;
 109                 result = exp(gamma * log(result));
 110                 return result;
 111         }
 112         else {
 113                 return ( val - minValue() ) / ( maxValue() - minValue() );
 114         }
 115 }
 116
 117 QColor KalziumGradientType::firstColor() const
 118 {
 119         return Qt::white;
 120 }
 121
 122 QColor KalziumGradientType::secondColor() const
 123 {
 124         return Qt::red;
 125 }
 126
 127 QColor KalziumGradientType::notAvailableColor() const
 128 {
 129         return Qt::lightGray;
 130 }
 131
 132 QColor KalziumGradientType::calculateColor( const double coeff ) const
 133 {
 134         if ( ( coeff < 0.0 ) || ( coeff > 1.0 ) ) return notAvailableColor();
 135
 136         QColor color2 = secondColor();
 137         QColor color1 = firstColor();
 138
 139         int red = static_cast<int>( (color2.red() - color1.red()) * coeff + color1.red() );
 140         int green = static_cast<int>( (color2.green() - color1.green()) * coeff + color1.green() );
 141         int blue = static_cast<int>( (color2.blue() - color1.blue()) * coeff + color1.blue() );
 142
 143         return QColor( red, green, blue );
 144 }
 145
 146 KalziumCovalentRadiusGradientType* KalziumCovalentRadiusGradientType::instance()
 147 {
 148         static KalziumCovalentRadiusGradientType kcrgt;
 149         return &kcrgt;
 150 }
 151
 152 KalziumCovalentRadiusGradientType::KalziumCovalentRadiusGradientType()
 153   : KalziumGradientType()
 154 {
 155 }
 156
 157 QByteArray KalziumCovalentRadiusGradientType::name() const
 158 {
 159         return "CovalentRadius";
 160 }
 161
 162 QString KalziumCovalentRadiusGradientType::description() const
 163 {
 164         return i18n( "Covalent Radius" );
 165 }
 166
 167 double KalziumCovalentRadiusGradientType::value( int el ) const
 168 {
 169         QVariant v = KalziumDataObject::instance()->element( el )->dataAsVariant( ChemicalDataObject::radiusCovalent );
 170         if ( v.type() != QVariant::Double ) return -1;
 171         return v.toDouble();
 172 }
 173
 174 double KalziumCovalentRadiusGradientType::minValue() const
 175 {
 176         return 0.32;
 177 }
 178
 179 double KalziumCovalentRadiusGradientType::maxValue() const
 180 {
 181         return 2.25;
 182 }
 183
 184 bool KalziumCovalentRadiusGradientType::logarithmicGradient() const
 185 {
 186         return Prefs::logarithmicCovalentRadiusGradient();
 187 }
 188
 189
 190 KalziumVanDerWaalsRadiusGradientType* KalziumVanDerWaalsRadiusGradientType::instance()
 191 {
 192         static KalziumVanDerWaalsRadiusGradientType kvdwrgt;
 193         return &kvdwrgt;
 194 }
 195
 196 KalziumVanDerWaalsRadiusGradientType::KalziumVanDerWaalsRadiusGradientType()
 197   : KalziumGradientType()
 198 {
 199 }
 200
 201 QByteArray KalziumVanDerWaalsRadiusGradientType::name() const
 202 {
 203         return "KalziumVanDerWaalsRadiusGradientType";
 204 }
 205
 206 QString KalziumVanDerWaalsRadiusGradientType::description() const
 207 {
 208         return i18n( "van Der Waals" );
 209 }
 210
 211 double KalziumVanDerWaalsRadiusGradientType::value( int el ) const
 212 {
 213         QVariant v = KalziumDataObject::instance()->element( el )->dataAsVariant( ChemicalDataObject::radiusVDW );
 214         if ( v.type() != QVariant::Double ) return -1;
 215         return v.toDouble();
 216 }
 217
 218 double KalziumVanDerWaalsRadiusGradientType::minValue() const
 219 {
 220         return 1.2;
 221 }
 222
 223 double KalziumVanDerWaalsRadiusGradientType::maxValue() const
 224 {
 225         return 3.0;
 226 }
 227
 228 bool KalziumVanDerWaalsRadiusGradientType::logarithmicGradient() const
 229 {
 230         return Prefs::logarithmicVanDerWaalsRadiusGradient();
 231 }
 232
 233
 234 KalziumMassGradientType* KalziumMassGradientType::instance()
 235 {
 236         static KalziumMassGradientType kargt;
 237         return &kargt;
 238 }
 239
 240 KalziumMassGradientType::KalziumMassGradientType()
 241   : KalziumGradientType()
 242 {
 243 }
 244
 245 QByteArray KalziumMassGradientType::name() const
 246 {
 247         return "AtomicMass";
 248 }
 249
 250 QString KalziumMassGradientType::description() const
 251 {
 252         return i18n( "Atomic Mass" );
 253 }
 254
 255 double KalziumMassGradientType::value( int el ) const
 256 {
 257         QVariant v = KalziumDataObject::instance()->element( el )->dataAsVariant( ChemicalDataObject::mass );
 258         if ( v.type() != QVariant::Double ) return -1;
 259         return v.toDouble();
 260 }
 261
 262 double KalziumMassGradientType::minValue() const
 263 {
 264         return 1.00794;
 265 }
 266
 267 double KalziumMassGradientType::maxValue() const
 268 {
 269         return 292.0;
 270 }
 271
 272 bool KalziumMassGradientType::logarithmicGradient() const
 273 {
 274         return Prefs::logarithmicMassGradient();
 275 }
 276
 277 KalziumBoilingPointGradientType* KalziumBoilingPointGradientType::instance()
 278 {
 279         static KalziumBoilingPointGradientType kbpgt;
 280         return &kbpgt;
 281 }
 282
 283 KalziumBoilingPointGradientType::KalziumBoilingPointGradientType()
 284   : KalziumGradientType()
 285 {
 286 }
 287
 288 QByteArray KalziumBoilingPointGradientType::name() const
 289 {
 290         return "BoilingPoint";
 291 }
 292
 293 QString KalziumBoilingPointGradientType::description() const
 294 {
 295         return i18n( "Boiling Point" );
 296 }
 297
 298 double KalziumBoilingPointGradientType::value( int el ) const
 299 {
 300         QVariant v = KalziumDataObject::instance()->element( el )->dataAsVariant( ChemicalDataObject::boilingpoint );
 301         if ( v.type() != QVariant::Double ) return -1;
 302         return v.toDouble();
 303 }
 304
 305 double KalziumBoilingPointGradientType::minValue() const
 306 {
 307         return 4.216;
 308 }
 309
 310 double KalziumBoilingPointGradientType::maxValue() const
 311 {
 312         return 5870.0;
 313 }
 314
 315 bool KalziumBoilingPointGradientType::logarithmicGradient() const
 316 {
 317         return Prefs::logarithmicBoilingPointGradient();
 318 }
 319
 320 KalziumMeltingPointGradientType* KalziumMeltingPointGradientType::instance()
 321 {
 322         static KalziumMeltingPointGradientType kmpgt;
 323         return &kmpgt;
 324 }
 325
 326 KalziumMeltingPointGradientType::KalziumMeltingPointGradientType()
 327   : KalziumGradientType()
 328 {
 329 }
 330
 331 QByteArray KalziumMeltingPointGradientType::name() const
 332 {
 333         return "MeltingPoint";
 334 }
 335
 336 QString KalziumMeltingPointGradientType::description() const
 337 {
 338         return i18n( "Melting Point" );
 339 }
 340
 341 double KalziumMeltingPointGradientType::value( int el ) const
 342 {
 343         QVariant v = KalziumDataObject::instance()->element( el )->dataAsVariant( ChemicalDataObject::meltingpoint );
 344         if ( v.type() != QVariant::Double ) return -1;
 345         return v.toDouble();
 346 }
 347
 348 double KalziumMeltingPointGradientType::minValue() const
 349 {
 350         return 0.94;
 351 }
 352
 353 double KalziumMeltingPointGradientType::maxValue() const
 354 {
 355         return 3825.0;
 356 }
 357
 358 bool KalziumMeltingPointGradientType::logarithmicGradient() const
 359 {
 360         return Prefs::logarithmicMeltingPointGradient();
 361 }
 362
 363
 364 KalziumElectronegativityGradientType* KalziumElectronegativityGradientType::instance()
 365 {
 366         static KalziumElectronegativityGradientType kegt;
 367         return &kegt;
 368 }
 369
 370 KalziumElectronegativityGradientType::KalziumElectronegativityGradientType()
 371   : KalziumGradientType()
 372 {
 373 }
 374
 375 QByteArray KalziumElectronegativityGradientType::name() const
 376 {
 377         return "Electronegativity";
 378 }
 379
 380 QString KalziumElectronegativityGradientType::description() const
 381 {
 382         return i18n( "Electronegativity (Pauling)" );
 383 }
 384
 385 double KalziumElectronegativityGradientType::value( int el ) const
 386 {
 387         QVariant v = KalziumDataObject::instance()->element( el )->dataAsVariant( ChemicalDataObject::electronegativityPauling );
 388         if ( v.type() != QVariant::Double ) return -1;
 389         return v.toDouble();
 390 }
 391
 392 double KalziumElectronegativityGradientType::minValue() const
 393 {
 394         return 0.7;
 395 }
 396
 397 double KalziumElectronegativityGradientType::maxValue() const
 398 {
 399         return 3.98;
 400 }
 401
 402 bool KalziumElectronegativityGradientType::logarithmicGradient() const
 403 {
 404         return Prefs::logarithmicElectronegativityGradient();
 405 }
 406
 407 ///DISCOVERYDATE///
 408
 409 KalziumDiscoverydateGradientType* KalziumDiscoverydateGradientType::instance()
 410 {
 411         static KalziumDiscoverydateGradientType kegt;
 412         return &kegt;
 413 }
 414
 415 KalziumDiscoverydateGradientType::KalziumDiscoverydateGradientType()
 416   : KalziumGradientType()
 417 {
 418 }
 419
 420 QByteArray KalziumDiscoverydateGradientType::name() const
 421 {
 422         return "Discoverydate";
 423 }
 424
 425 QString KalziumDiscoverydateGradientType::description() const
 426 {
 427         return i18n( "Discoverydate" );
 428 }
 429
 430 double KalziumDiscoverydateGradientType::value( int el ) const
 431 {
 432         QVariant v = KalziumDataObject::instance()->element( el )->dataAsVariant( ChemicalDataObject::date );
 433
 434         return v.toDouble();
 435 }
 436
 437 double KalziumDiscoverydateGradientType::minValue() const
 438 {
 439         return 1699.0;
 440 }
 441
 442 double KalziumDiscoverydateGradientType::maxValue() const
 443 {
 444         return 1994.0;
 445 }
 446
 447 bool KalziumDiscoverydateGradientType::logarithmicGradient() const
 448 {
 449         return Prefs::logarithmicDiscoverydateGradient();
 450 }
 451
 452
 453 ///ELECTRONAFFINITY///
 454
 455 KalziumElectronaffinityGradientType* KalziumElectronaffinityGradientType::instance()
 456 {
 457         static KalziumElectronaffinityGradientType kegt;
 458         return &kegt;
 459 }
 460
 461 KalziumElectronaffinityGradientType::KalziumElectronaffinityGradientType()
 462   : KalziumGradientType()
 463 {
 464 }
 465
 466 QByteArray KalziumElectronaffinityGradientType::name() const
 467 {
 468         return "Electronaffinity";
 469 }
 470
 471 QString KalziumElectronaffinityGradientType::description() const
 472 {
 473         return i18n( "Electronaffinity" );
 474 }
 475
 476 double KalziumElectronaffinityGradientType::value( int el ) const
 477 {
 478         QVariant v = KalziumDataObject::instance()->element( el )->dataAsVariant( ChemicalDataObject::electronAffinity );
 479
 480         return v.toDouble();
 481 }
 482
 483 double KalziumElectronaffinityGradientType::minValue() const
 484 {
 485         return 0.0;
 486 }
 487
 488 double KalziumElectronaffinityGradientType::maxValue() const
 489 {
 490         return 3.7;
 491 }
 492
 493 bool KalziumElectronaffinityGradientType::logarithmicGradient() const
 494 {
 495         return Prefs::logarithmicElectronaffinityGradient();
 496 }
 497
 498 ///FIRST IONIZATINO///
 499
 500 KalziumIonizationGradientType* KalziumIonizationGradientType::instance()
 501 {
 502         static KalziumIonizationGradientType kegt;
 503         return &kegt;
 504 }
 505
 506 KalziumIonizationGradientType::KalziumIonizationGradientType()
 507   : KalziumGradientType()
 508 {
 509 }
 510
 511 QByteArray KalziumIonizationGradientType::name() const
 512 {
 513         return "Ionization";
 514 }
 515
 516 QString KalziumIonizationGradientType::description() const
 517 {
 518         return i18n( "First Ionization" );
 519 }
 520
 521 double KalziumIonizationGradientType::value( int el ) const
 522 {
 523         QVariant v = KalziumDataObject::instance()->element( el )->dataAsVariant( ChemicalDataObject::ionization );
 524
 525         return v.toDouble();
 526 }
 527
 528 double KalziumIonizationGradientType::minValue() const
 529 {
 530         return 0.0;//3.89;
 531 }
 532
 533 double KalziumIonizationGradientType::maxValue() const
 534 {
 535         return 25.0;
 536 }
 537
 538 bool KalziumIonizationGradientType::logarithmicGradient() const
 539 {
 540         return Prefs::logarithmicIonizationGradient();
 541 }